@oneuptime/common 11.6.0 → 11.6.2

package/Tests/UI/Components/ModelTable/FilterDataToQuery.test.ts

@@ -0,0 +1,275 @@
+import buildQueryFromFilterData, {
+  getFilterKeys,
+  sanitizeFilterData,
+} from "../../../../UI/Components/ModelTable/FilterDataToQuery";
+import Filter from "../../../../UI/Components/ModelFilter/Filter";
+import FieldType from "../../../../UI/Components/Types/FieldType";
+import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import Includes from "../../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../../Types/BaseDatabase/IncludesNone";
+import InBetween from "../../../../Types/BaseDatabase/InBetween";
+import IsNull from "../../../../Types/BaseDatabase/IsNull";
+import NotEqual from "../../../../Types/BaseDatabase/NotEqual";
+import Search from "../../../../Types/BaseDatabase/Search";
+import Query from "../../../../Types/BaseDatabase/Query";
+import FilterData from "../../../../UI/Components/Filters/Types/FilterData";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * `buildQueryFromFilterData` is what turns the filter popup's selections into
+ * the query the table fetches with. It lives outside the component so the
+ * table can derive its query *synchronously during the first render* when
+ * filters come back from the URL — without that, the first request would go
+ * out unfiltered and be immediately superseded, flashing the wrong rows.
+ *
+ * `sanitizeFilterData` is the trust boundary for that same path: the snapshot
+ * arrives from a query string anyone can edit.
+ */
+
+const FILTERS: Array<Filter<Monitor>> = [
+  { title: "Name", type: FieldType.Text, field: { name: true } },
+  {
+    title: "Description",
+    type: FieldType.Text,
+    field: { description: true },
+  },
+  {
+    title: "Monitoring disabled",
+    type: FieldType.Boolean,
+    field: { disableActiveMonitoring: true },
+  },
+  { title: "Created", type: FieldType.Date, field: { createdAt: true } },
+  { title: "Labels", type: FieldType.EntityArray, field: { labels: true } },
+  {
+    title: "Custom fields",
+    type: FieldType.JSON,
+    field: { customFields: true },
+  },
+] as unknown as Array<Filter<Monitor>>;
+
+type BuildFunction = (filterData: FilterData<Monitor>) => Query<Monitor>;
+
+const build: BuildFunction = (
+  filterData: FilterData<Monitor>,
+): Query<Monitor> => {
+  return buildQueryFromFilterData<Monitor>({
+    filterData: filterData,
+    filters: FILTERS,
+  });
+};
+
+describe("getFilterKeys", () => {
+  test("returns the model field behind each declared filter", () => {
+    expect(getFilterKeys<Monitor>(FILTERS)).toEqual([
+      "name",
+      "description",
+      "disableActiveMonitoring",
+      "createdAt",
+      "labels",
+      "customFields",
+    ]);
+  });
+
+  test("tolerates an empty or missing filter list", () => {
+    expect(getFilterKeys<Monitor>([])).toEqual([]);
+    expect(
+      getFilterKeys<Monitor>(undefined as unknown as Array<Filter<Monitor>>),
+    ).toEqual([]);
+  });
+});
+
+describe("buildQueryFromFilterData", () => {
+  test("returns an empty query for no filters", () => {
+    expect(build({})).toEqual({});
+  });
+
+  test("passes a text value through", () => {
+    expect(build({ name: "api" } as FilterData<Monitor>)).toEqual({
+      name: "api",
+    });
+  });
+
+  test("keeps a false boolean — it is a real constraint, not an absent one", () => {
+    expect(
+      build({
+        disableActiveMonitoring: false,
+      } as unknown as FilterData<Monitor>),
+    ).toEqual({ disableActiveMonitoring: false });
+  });
+
+  test("keeps a zero number", () => {
+    const query: Query<Monitor> = build({
+      name: 0,
+    } as unknown as FilterData<Monitor>);
+
+    expect(query).toEqual({ name: 0 });
+  });
+
+  test("passes a Date through unchanged", () => {
+    const date: Date = new Date("2026-07-01T12:34:56.789Z");
+
+    expect(
+      build({ createdAt: date } as unknown as FilterData<Monitor>)["createdAt"],
+    ).toBe(date);
+  });
+
+  test("passes a Search through unchanged", () => {
+    const search: Search<string> = new Search("api");
+
+    expect(
+      build({ name: search } as unknown as FilterData<Monitor>)["name"],
+    ).toBe(search);
+  });
+
+  test("passes an InBetween through unchanged", () => {
+    const range: InBetween<Date> = new InBetween(
+      new Date("2026-01-01T00:00:00.000Z"),
+      new Date("2026-02-01T00:00:00.000Z"),
+    );
+
+    expect(
+      build({ createdAt: range } as unknown as FilterData<Monitor>)[
+        "createdAt"
+      ],
+    ).toBe(range);
+  });
+
+  test("wraps a bare array into an Includes", () => {
+    const query: Query<Monitor> = build({
+      labels: ["a", "b"],
+    } as unknown as FilterData<Monitor>);
+
+    expect(query["labels"]).toBeInstanceOf(Includes);
+    expect((query["labels"] as Includes).values).toEqual(["a", "b"]);
+  });
+
+  test("passes any QueryOperator through as-is", () => {
+    const operators: Record<string, unknown> = {
+      includesNone: new IncludesNone(["a"]),
+      isNull: new IsNull(),
+      notEqual: new NotEqual("api"),
+    };
+
+    for (const operator of Object.values(operators)) {
+      expect(
+        build({ name: operator } as unknown as FilterData<Monitor>)["name"],
+      ).toBe(operator);
+    }
+  });
+
+  test("passes a plain object through only for a JSON-typed filter", () => {
+    const value: Record<string, string> = { team: "platform" };
+
+    expect(
+      build({ customFields: value } as unknown as FilterData<Monitor>)[
+        "customFields"
+      ],
+    ).toBe(value);
+  });
+
+  test("drops a plain object on a non-JSON filter", () => {
+    expect(
+      build({ name: { nope: true } } as unknown as FilterData<Monitor>),
+    ).toEqual({});
+  });
+
+  test("drops an empty string — an empty text box is not a filter", () => {
+    expect(build({ name: "" } as unknown as FilterData<Monitor>)).toEqual({});
+  });
+
+  test("builds every kind of value in one pass", () => {
+    const query: Query<Monitor> = build({
+      name: new Search("api"),
+      disableActiveMonitoring: false,
+      labels: ["a"],
+    } as unknown as FilterData<Monitor>);
+
+    expect(query["name"]).toBeInstanceOf(Search);
+    expect(query["disableActiveMonitoring"]).toBe(false);
+    expect(query["labels"]).toBeInstanceOf(Includes);
+  });
+});
+
+describe("sanitizeFilterData", () => {
+  type SanitizeFunction = (
+    filterData: FilterData<Monitor>,
+  ) => FilterData<Monitor>;
+
+  const sanitize: SanitizeFunction = (
+    filterData: FilterData<Monitor>,
+  ): FilterData<Monitor> => {
+    return sanitizeFilterData<Monitor>({
+      filterData: filterData,
+      filters: FILTERS,
+    });
+  };
+
+  test("keeps every field the table declares a filter for", () => {
+    expect(
+      sanitize({ name: "api", description: "prod" } as FilterData<Monitor>),
+    ).toEqual({ name: "api", description: "prod" });
+  });
+
+  test("drops a field the table does not expose a filter for", () => {
+    /*
+     * The restored filter is spread into the outgoing list query, so an
+     * undeclared key in a hand-edited link would otherwise become a real
+     * constraint the filter UI could never have produced.
+     */
+    expect(
+      sanitize({
+        name: "api",
+        projectId: "somebody-elses-project",
+      } as unknown as FilterData<Monitor>),
+    ).toEqual({ name: "api" });
+  });
+
+  test("drops a key that tries to re-scope the page's own query", () => {
+    expect(
+      sanitize({
+        monitorId: "another-monitor",
+        _id: "specific-row",
+      } as unknown as FilterData<Monitor>),
+    ).toEqual({});
+  });
+
+  test("drops null and undefined values", () => {
+    expect(
+      sanitize({
+        name: "api",
+        description: undefined,
+        createdAt: null,
+      } as unknown as FilterData<Monitor>),
+    ).toEqual({ name: "api" });
+  });
+
+  test("keeps a false boolean", () => {
+    expect(
+      sanitize({
+        disableActiveMonitoring: false,
+      } as unknown as FilterData<Monitor>),
+    ).toEqual({ disableActiveMonitoring: false });
+  });
+
+  test("keeps typed operator instances intact", () => {
+    const search: Search<string> = new Search("api");
+
+    expect(
+      sanitize({ name: search } as unknown as FilterData<Monitor>)["name"],
+    ).toBe(search);
+  });
+
+  test("returns an empty object when the table declares no filters at all", () => {
+    expect(
+      sanitizeFilterData<Monitor>({
+        filterData: { name: "api" } as FilterData<Monitor>,
+        filters: [],
+      }),
+    ).toEqual({});
+  });
+
+  test("tolerates an empty snapshot", () => {
+    expect(sanitize({})).toEqual({});
+    expect(sanitize(undefined as unknown as FilterData<Monitor>)).toEqual({});
+  });
+});

package/Tests/UI/Utils/LogExport.test.ts

@@ -0,0 +1,159 @@
+import Log from "../../../Models/AnalyticsModels/Log";
+import { JSONObject } from "../../../Types/JSON";
+import { exportLogsToCSV, exportLogsToJSON } from "../../../UI/Utils/LogExport";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * LogExport turns a set of Log rows + selected columns into CSV/JSON that the
+ * user downloads. The two pure serializers are what these tests guard:
+ *
+ *   - CSV escaping (RFC-4180 style: quote fields containing comma/quote/newline,
+ *     double embedded quotes) — a bug here corrupts every exported file.
+ *   - Column resolution, including the "attribute:<key>" dynamic columns that
+ *     read out of the log's attributes bag.
+ */
+
+function makeLog(fields: {
+  time?: Date;
+  body?: string;
+  traceId?: string;
+  spanId?: string;
+  severityText?: string;
+  attributes?: JSONObject;
+}): Log {
+  const log: Log = new Log();
+  if (fields.time) {
+    log.time = fields.time;
+  }
+  if (fields.body !== undefined) {
+    log.body = fields.body;
+  }
+  if (fields.traceId !== undefined) {
+    log.traceId = fields.traceId;
+  }
+  if (fields.spanId !== undefined) {
+    log.spanId = fields.spanId;
+  }
+  if (fields.severityText !== undefined) {
+    log.severityText = fields.severityText as unknown as Log["severityText"];
+  }
+  if (fields.attributes !== undefined) {
+    log.attributes = fields.attributes;
+  }
+  return log;
+}
+
+describe("exportLogsToCSV", () => {
+  test("emits a header row of human-readable labels", () => {
+    const csv: string = exportLogsToCSV([], ["time", "message", "traceId"]);
+    expect(csv).toBe("Time,Message,Trace ID");
+  });
+
+  test("serializes body/traceId/spanId fields into a row", () => {
+    const log: Log = makeLog({
+      body: "hello world",
+      traceId: "trace-1",
+      spanId: "span-1",
+    });
+
+    const csv: string = exportLogsToCSV(
+      [log],
+      ["message", "traceId", "spanId"],
+    );
+    const [, row] = csv.split("\n");
+    expect(row).toBe("hello world,trace-1,span-1");
+  });
+
+  test("quotes and escapes fields containing commas and quotes", () => {
+    const log: Log = makeLog({ body: 'a, b "c"' });
+    const csv: string = exportLogsToCSV([log], ["message"]);
+    // Message,\n"a, b ""c"""
+    expect(csv.split("\n")[1]).toBe('"a, b ""c"""');
+  });
+
+  test("quotes fields containing newlines", () => {
+    const log: Log = makeLog({ body: "line1\nline2" });
+    const csv: string = exportLogsToCSV([log], ["message"]);
+    // The whole field (including the embedded newline) is wrapped in quotes.
+    expect(csv).toBe('Message\n"line1\nline2"');
+  });
+
+  test("renders an ISO timestamp for the time column", () => {
+    const log: Log = makeLog({ time: new Date("2026-07-25T10:20:30.000Z") });
+    const csv: string = exportLogsToCSV([log], ["time"]);
+    expect(csv.split("\n")[1]).toBe("2026-07-25T10:20:30.000Z");
+  });
+
+  test("empty value for a missing scalar field", () => {
+    const log: Log = makeLog({ body: "x" });
+    const csv: string = exportLogsToCSV([log], ["traceId"]);
+    expect(csv.split("\n")[1]).toBe("");
+  });
+
+  test("reads dynamic attribute columns via the attribute: prefix", () => {
+    const log: Log = makeLog({
+      attributes: { "http.method": "GET", nested: { a: 1 } },
+    });
+
+    const csv: string = exportLogsToCSV(
+      [log],
+      ["attribute:http.method", "attribute:nested"],
+    );
+    const row: string = csv.split("\n")[1]!;
+    // nested object is JSON-stringified, which contains a comma -> quoted.
+    expect(row).toContain("GET");
+    expect(row).toContain('"{""a"":1}"');
+  });
+
+  test("attribute column is empty when the key is absent", () => {
+    const log: Log = makeLog({ attributes: { present: "1" } });
+    const csv: string = exportLogsToCSV([log], ["attribute:missing"]);
+    expect(csv.split("\n")[1]).toBe("");
+  });
+
+  test("unknown column id yields an empty cell and echoes the id as label", () => {
+    const log: Log = makeLog({ body: "x" });
+    const csv: string = exportLogsToCSV([log], ["totally-unknown"]);
+    expect(csv.split("\n")[0]).toBe("totally-unknown");
+    expect(csv.split("\n")[1]).toBe("");
+  });
+});
+
+describe("exportLogsToJSON", () => {
+  test("produces a pretty-printed array of log objects", () => {
+    const log: Log = makeLog({
+      time: new Date("2026-07-25T10:20:30.000Z"),
+      body: "hello",
+      traceId: "t1",
+      spanId: "s1",
+      attributes: { k: "v" },
+    });
+
+    const json: string = exportLogsToJSON([log]);
+    const parsed: Array<Record<string, unknown>> = JSON.parse(json);
+
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0]!["time"]).toBe("2026-07-25T10:20:30.000Z");
+    expect(parsed[0]!["body"]).toBe("hello");
+    expect(parsed[0]!["traceId"]).toBe("t1");
+    expect(parsed[0]!["spanId"]).toBe("s1");
+    expect(parsed[0]!["attributes"]).toEqual({ k: "v" });
+  });
+
+  test("null fields for a sparse log, empty attributes object default", () => {
+    const log: Log = makeLog({ body: "only body" });
+    const parsed: Array<Record<string, unknown>> = JSON.parse(
+      exportLogsToJSON([log]),
+    );
+
+    expect(parsed[0]!["time"]).toBeNull();
+    expect(parsed[0]!["traceId"]).toBeNull();
+    expect(parsed[0]!["spanId"]).toBeNull();
+    expect(parsed[0]!["attributes"]).toEqual({});
+    expect(parsed[0]!["body"]).toBe("only body");
+  });
+
+  test("serializes an empty list to an empty JSON array", () => {
+    expect(exportLogsToJSON([])).toBe("[]");
+  });
+});

package/Tests/UI/Utils/Navigation.test.ts

@@ -0,0 +1,183 @@
+import Navigation from "../../../UI/Utils/Navigation";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * `Navigation.setQueryString` is the single write path for every piece of URL
+ * state in the app (table filters, facets, sort/pagination, the telemetry
+ * explorers). Its exact semantics are load-bearing:
+ *
+ *  - it must MERGE, so one component writing its params never deletes another
+ *    component's params from the same route;
+ *  - it must use `replaceState`, so dragging a filter around doesn't bury the
+ *    "back to the list" entry under a hundred history entries;
+ *  - it must pass the CURRENT `history.state` through, because that object is
+ *    react-router's `{usr, key, idx}` bookkeeping — replacing it with `null`
+ *    corrupts the router's history index;
+ *  - and it must leave the pathname and hash alone.
+ */
+
+type SetUrlFunction = (url: string) => void;
+
+const setUrl: SetUrlFunction = (url: string): void => {
+  window.history.replaceState(window.history.state, "", url);
+};
+
+describe("Navigation URL query string helpers", () => {
+  beforeEach(() => {
+    setUrl("/dashboard/monitors");
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("getQueryString", () => {
+    test("returns the raw search string including the leading ?", () => {
+      setUrl("/dashboard/monitors?a=1&b=2");
+
+      expect(Navigation.getQueryString()).toBe("?a=1&b=2");
+    });
+
+    test("returns an empty string when there is no query", () => {
+      expect(Navigation.getQueryString()).toBe("");
+    });
+  });
+
+  describe("getQueryStringByName", () => {
+    test("reads a param and percent-decodes it", () => {
+      setUrl(`/dashboard/monitors?q=${encodeURIComponent('{"a":"b c"}')}`);
+
+      expect(Navigation.getQueryStringByName("q")).toBe('{"a":"b c"}');
+    });
+
+    test("returns null for a missing param", () => {
+      setUrl("/dashboard/monitors?other=1");
+
+      expect(Navigation.getQueryStringByName("q")).toBeNull();
+    });
+
+    test("returns null for a present-but-empty param", () => {
+      setUrl("/dashboard/monitors?q=");
+
+      expect(Navigation.getQueryStringByName("q")).toBeNull();
+    });
+  });
+
+  describe("setQueryString", () => {
+    test("adds a param without touching the ones already there", () => {
+      setUrl("/dashboard/monitors?existing=keepme");
+
+      Navigation.setQueryString({ added: "value" });
+
+      expect(Navigation.getQueryStringByName("existing")).toBe("keepme");
+      expect(Navigation.getQueryStringByName("added")).toBe("value");
+    });
+
+    test("overwrites only the named param", () => {
+      setUrl("/dashboard/monitors?a=1&b=2");
+
+      Navigation.setQueryString({ a: "9" });
+
+      expect(Navigation.getQueryStringByName("a")).toBe("9");
+      expect(Navigation.getQueryStringByName("b")).toBe("2");
+    });
+
+    test("deletes a param when the value is null", () => {
+      setUrl("/dashboard/monitors?a=1&b=2");
+
+      Navigation.setQueryString({ a: null });
+
+      expect(Navigation.getQueryStringByName("a")).toBeNull();
+      expect(Navigation.getQueryStringByName("b")).toBe("2");
+    });
+
+    test("deletes a param when the value is an empty string", () => {
+      setUrl("/dashboard/monitors?a=1");
+
+      Navigation.setQueryString({ a: "" });
+
+      expect(Navigation.getQueryStringByName("a")).toBeNull();
+    });
+
+    test("applies several params in one call", () => {
+      setUrl("/dashboard/monitors?keep=1&drop=2");
+
+      Navigation.setQueryString({ drop: null, one: "1", two: "2" });
+
+      expect(Navigation.getQueryStringByName("keep")).toBe("1");
+      expect(Navigation.getQueryStringByName("drop")).toBeNull();
+      expect(Navigation.getQueryStringByName("one")).toBe("1");
+      expect(Navigation.getQueryStringByName("two")).toBe("2");
+    });
+
+    test("leaves the pathname and hash intact", () => {
+      setUrl("/dashboard/monitors/abc#section-two");
+
+      Navigation.setQueryString({ a: "1" });
+
+      expect(window.location.pathname).toBe("/dashboard/monitors/abc");
+      expect(window.location.hash).toBe("#section-two");
+      expect(Navigation.getQueryStringByName("a")).toBe("1");
+    });
+
+    test("drops the '?' entirely when the last param is removed", () => {
+      setUrl("/dashboard/monitors?only=1");
+
+      Navigation.setQueryString({ only: null });
+
+      expect(window.location.search).toBe("");
+    });
+
+    test("round-trips a value containing URL-significant characters", () => {
+      const value: string = '{"name":{"_type":"Search","value":"a&b=c d"}}';
+
+      Navigation.setQueryString({ q: value });
+
+      expect(Navigation.getQueryStringByName("q")).toBe(value);
+    });
+
+    test("replaces the current history entry instead of pushing a new one", () => {
+      const lengthBefore: number = window.history.length;
+
+      Navigation.setQueryString({ a: "1" });
+      Navigation.setQueryString({ a: "2" });
+      Navigation.setQueryString({ a: "3" });
+
+      expect(window.history.length).toBe(lengthBefore);
+    });
+
+    test("preserves history.state so react-router's bookkeeping survives", () => {
+      const routerState: { usr: null; key: string; idx: number } = {
+        usr: null,
+        key: "abc123",
+        idx: 4,
+      };
+      window.history.replaceState(routerState, "", "/dashboard/monitors");
+
+      Navigation.setQueryString({ a: "1" });
+
+      expect(window.history.state).toEqual(routerState);
+    });
+
+    test("swallows the SecurityError Safari throws when replaceState is called too often", () => {
+      const replaceState: ReturnType<typeof jest.spyOn> = jest
+        .spyOn(window.history, "replaceState")
+        .mockImplementation(() => {
+          throw new Error("SecurityError: too many calls to replaceState");
+        });
+
+      expect(() => {
+        Navigation.setQueryString({ a: "1" });
+      }).not.toThrow();
+
+      expect(replaceState).toHaveBeenCalled();
+    });
+  });
+});