@oneuptime/common 11.7.2 → 11.7.4

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

@@ -9,7 +9,9 @@ import NotEqual from "../../../Types/BaseDatabase/NotEqual";
 import NotNull from "../../../Types/BaseDatabase/NotNull";
 import Search from "../../../Types/BaseDatabase/Search";
 import ObjectID from "../../../Types/ObjectID";
+import Dictionary from "../../../Types/Dictionary";
 import { JSONObject } from "../../../Types/JSON";
+import JSONFunctions from "../../../Types/JSONFunctions";
 import {
   afterEach,
   beforeEach,
@@ -31,6 +33,8 @@ import {
  *    their own filters;
  *  - a hand-edited or truncated param degrades to "no filters", never to a
  *    crash;
+ *  - a link built elsewhere in the product (a summary count whose rows live on
+ *    another page) lands that page in the state it names;
  *  - and the URL can't grow without bound.
  */
 
@@ -86,6 +90,29 @@ describe("TableFilterUrlState", () => {
         "monitors-table-view",
       ]);
     });
+
+    /*
+     * The link builder and the reader have to agree on the param name or a
+     * "show me these rows" link silently lands on an unfiltered table. This is
+     * the one place naming is pinned, so keep the writer in it.
+     */
+    test("the names getLinkQueryParams writes are the names read looks up", () => {
+      const params: Dictionary<string> = TableFilterUrlState.getLinkQueryParams(
+        "monitors-table",
+        {
+          filter: { name: "api" },
+          facets: { selectedLabelIds: ["a"] },
+          view: { page: 2 },
+        },
+      );
+
+      expect(Object.keys(params).sort()).toEqual(
+        [...TableFilterUrlState.getAllParamNames("monitors-table")].sort(),
+      );
+      expect(Object.keys(params)).toContain(
+        TableFilterUrlState.getParamName("monitors-table", "facets"),
+      );
+    });
   });
 
   describe("read", () => {
@@ -403,6 +430,271 @@ describe("TableFilterUrlState", () => {
     });
   });
 
+  describe("serializeState", () => {
+    type BuildCircularStateFunction = () => JSONObject;
+
+    /*
+     * Filter data never looks like this, but a caller passing a React object
+     * with a back-reference by accident must not take the table down with it.
+     */
+    const buildCircularState: BuildCircularStateFunction = (): JSONObject => {
+      const state: JSONObject = { name: "api" };
+      state["self"] = state;
+      return state;
+    };
+
+    /*
+     * "Nothing to write" and "could not write" have to be indistinguishable to
+     * a caller, because both mean "put no param on the URL". read() treats a
+     * missing param and an object with no keys the same way, so an object with
+     * no keys must never reach the URL as a param either.
+     */
+    test("returns null for every flavour of empty", () => {
+      expect(TableFilterUrlState.serializeState(null)).toBeNull();
+      expect(TableFilterUrlState.serializeState(undefined)).toBeNull();
+      expect(TableFilterUrlState.serializeState({})).toBeNull();
+    });
+
+    test("returns a JSON string for a plain object", () => {
+      const serialized: string | null = TableFilterUrlState.serializeState({
+        name: "api",
+        disableActiveMonitoring: false,
+        count: 12,
+      });
+
+      expect(typeof serialized).toBe("string");
+      expect(JSON.parse(serialized as string)).toEqual({
+        name: "api",
+        disableActiveMonitoring: false,
+        count: 12,
+      });
+    });
+
+    /*
+     * Serialization goes through JSONFunctions rather than plain stringify for
+     * exactly one reason: type fidelity. A bare JSON.stringify would flatten an
+     * Includes to `{}` and the restored query would mean "no constraint"
+     * instead of "one of these ids" — a table showing every row instead of
+     * three.
+     */
+    test("keeps typed query values recoverable as class instances", () => {
+      const ids: Array<string> = buildIds(2);
+
+      const serialized: string | null = TableFilterUrlState.serializeState({
+        name: new Search("api gateway"),
+        labels: new Includes(ids),
+        deletedAt: new IsNull(),
+      });
+
+      expect(serialized).not.toBeNull();
+
+      const restored: JSONObject = JSONFunctions.deserialize(
+        JSONFunctions.parseJSONObject(serialized as string),
+      );
+
+      expect(restored["name"]).toBeInstanceOf(Search);
+      expect((restored["name"] as Search<string>).toString()).toBe(
+        "api gateway",
+      );
+      expect(restored["labels"]).toBeInstanceOf(Includes);
+      expect(
+        (restored["labels"] as Includes).values.map((v: unknown) => {
+          return v!.toString();
+        }),
+      ).toEqual(ids);
+      expect(restored["deletedAt"]).toBeInstanceOf(IsNull);
+    });
+
+    test("returns null and warns instead of throwing on state it cannot serialize", () => {
+      const warn: ReturnType<typeof jest.spyOn> = jest
+        .spyOn(console, "warn")
+        .mockImplementation(() => {});
+
+      expect(
+        TableFilterUrlState.serializeState(buildCircularState()),
+      ).toBeNull();
+
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(String(warn.mock.calls[0]?.[0])).toContain(
+        "could not serialize state",
+      );
+    });
+
+    /*
+     * write/writeMany share this serializer, so a slice that will not
+     * serialize has to drop its param rather than leave the previous one behind
+     * describing an older view.
+     */
+    test("a slice that will not serialize drops its param instead of going stale", () => {
+      jest.spyOn(console, "warn").mockImplementation(() => {});
+
+      TableFilterUrlState.write("monitors-table", "filter", { name: "api" });
+
+      TableFilterUrlState.write(
+        "monitors-table",
+        "filter",
+        buildCircularState(),
+      );
+
+      expect(readParam("monitors-table-filter")).toBeNull();
+      expect(TableFilterUrlState.read("monitors-table", "filter")).toBeNull();
+    });
+  });
+
+  describe("getLinkQueryParams", () => {
+    type NavigateWithFunction = (params: Dictionary<string>) => void;
+
+    /*
+     * What Route.addQueryParams plus a real navigation do with these params:
+     * the values are concatenated into the route exactly as handed over.
+     */
+    const navigateWith: NavigateWithFunction = (
+      params: Dictionary<string>,
+    ): void => {
+      const query: string = Object.keys(params)
+        .map((name: string): string => {
+          return `${name}=${params[name]!}`;
+        })
+        .join("&");
+
+      setUrl(`/dashboard/monitors?${query}`);
+    };
+
+    test("names each param under the table id and slice", () => {
+      const params: Dictionary<string> = TableFilterUrlState.getLinkQueryParams(
+        "monitors-table",
+        { facets: { selectedLabelIds: ["a"] } },
+      );
+
+      expect(Object.keys(params)).toEqual(["monitors-table-facets"]);
+    });
+
+    /*
+     * Route.addQueryParams pastes values into the route verbatim while read()
+     * pulls them back out of URLSearchParams, which decodes. Serialized state
+     * is JSON — full of `{`, `"` and, in any search text, `&` — so an
+     * unencoded value would truncate at the first `&` and arrive as a param the
+     * reader cannot parse: a link that lands on an unfiltered table.
+     */
+    test("percent-encodes the value so the reader gets back what was written", () => {
+      const state: JSONObject = { name: new Search("api & gateway") };
+
+      const params: Dictionary<string> = TableFilterUrlState.getLinkQueryParams(
+        "monitors-table",
+        { facets: state },
+      );
+
+      const value: string = params["monitors-table-facets"]!;
+
+      expect(value).not.toContain("{");
+      expect(value).not.toContain('"');
+      expect(value).not.toContain("&");
+      expect(value).toContain("%7B");
+      expect(decodeURIComponent(value)).toBe(
+        TableFilterUrlState.serializeState(state),
+      );
+    });
+
+    /*
+     * An empty slice has to vanish, not become `monitors-table-facets=`. The
+     * absence of the param is already how read() spells "no state", and an
+     * empty one would ride along in every bookmark claiming the link carries
+     * state it does not.
+     */
+    test("omits empty slices entirely", () => {
+      const params: Dictionary<string> = TableFilterUrlState.getLinkQueryParams(
+        "monitors-table",
+        { filter: { name: "api" }, facets: null, view: {} },
+      );
+
+      expect(Object.keys(params)).toEqual(["monitors-table-filter"]);
+      expect(params["monitors-table-facets"]).toBeUndefined();
+      expect(params["monitors-table-view"]).toBeUndefined();
+    });
+
+    test("carries several slices in one link", () => {
+      const filter: JSONObject = { name: new Search("api") };
+      const facets: JSONObject = { selectedLabelIds: ["a", "b"] };
+      const view: JSONObject = { page: 3 };
+
+      const params: Dictionary<string> = TableFilterUrlState.getLinkQueryParams(
+        "monitors-table",
+        { filter, facets, view },
+      );
+
+      expect(decodeURIComponent(params["monitors-table-filter"]!)).toBe(
+        TableFilterUrlState.serializeState(filter),
+      );
+      expect(decodeURIComponent(params["monitors-table-facets"]!)).toBe(
+        TableFilterUrlState.serializeState(facets),
+      );
+      expect(decodeURIComponent(params["monitors-table-view"]!)).toBe(
+        TableFilterUrlState.serializeState(view),
+      );
+    });
+
+    test("asked for nothing, adds nothing to the link", () => {
+      expect(
+        TableFilterUrlState.getLinkQueryParams("monitors-table", {}),
+      ).toEqual({});
+    });
+
+    /*
+     * The property the whole feature rests on: a summary tile builds a link,
+     * the browser follows it, and the target table mounts already in that
+     * state — chip set, values typed, nothing lost to the URL round trip.
+     */
+    test("a link built from these params lands the table in that state", () => {
+      const ids: Array<string> = buildIds(2);
+      const state: JSONObject = {
+        name: new Search("api & gateway"),
+        labels: new Includes(ids),
+        deletedAt: new IsNull(),
+      };
+
+      navigateWith(
+        TableFilterUrlState.getLinkQueryParams("monitors-table", {
+          facets: state,
+        }),
+      );
+
+      const restored: JSONObject | null = TableFilterUrlState.read(
+        "monitors-table",
+        "facets",
+      );
+
+      expect(restored?.["name"]).toBeInstanceOf(Search);
+      expect((restored?.["name"] as Search<string>).toString()).toBe(
+        "api & gateway",
+      );
+      expect(restored?.["labels"]).toBeInstanceOf(Includes);
+      expect(
+        (restored?.["labels"] as Includes).values.map((v: unknown) => {
+          return v!.toString();
+        }),
+      ).toEqual(ids);
+      expect(restored?.["deletedAt"]).toBeInstanceOf(IsNull);
+    });
+
+    /*
+     * A link only carries the slices it names; the arriving table must not be
+     * told anything about the others.
+     */
+    test("a link's slices do not leak into another table or slice", () => {
+      navigateWith(
+        TableFilterUrlState.getLinkQueryParams("monitors-table", {
+          facets: { selectedLabelIds: ["a"] },
+        }),
+      );
+
+      expect(TableFilterUrlState.read("monitors-table", "facets")).toEqual({
+        selectedLabelIds: ["a"],
+      });
+      expect(TableFilterUrlState.read("monitors-table", "filter")).toBeNull();
+      expect(TableFilterUrlState.read("incidents-table", "facets")).toBeNull();
+    });
+  });
+
   describe("URL size guard", () => {
     type OversizedFilterFunction = () => JSONObject;
 

package/Tests/Utils/Monitor/MonitorSummaryProbeUtil.test.ts

@@ -0,0 +1,263 @@
+import MonitorSummaryProbeUtil, {
+  AttachedProbe,
+  MonitorSummaryProbeState,
+} from "../../../Utils/Monitor/MonitorSummaryProbeUtil";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * https://github.com/OneUptime/oneuptime/issues/2899
+ *
+ * The Monitor Summary card carries a "Select Probe" dropdown. It was fed every
+ * probe in the project plus every global probe - not the probes attached to the
+ * monitor being viewed. So a project with a global probe "Probe" and a custom
+ * probe "WBHQ" offered both on a monitor that only "Probe" watched, and picking
+ * "WBHQ" answered "No summary available for the selected probe. Should be few
+ * minutes for summary to show up." about data that was never going to arrive.
+ * Worse, the list is project-probes-first, so the card often *opened* on the
+ * stranger. The reporter's conclusion: "i have changed the probe, but the
+ * change was not actually applied".
+ *
+ * These pin the three rules that make the picker honest: it only offers
+ * attached probes, it keeps the user's choice, and it says which of the three
+ * empty states it is in.
+ */
+
+const GLOBAL_PROBE: AttachedProbe = {
+  id: "33333333-3333-4333-8333-333333333333",
+  name: "Probe",
+  isEnabled: true,
+};
+
+const CUSTOM_PROBE: AttachedProbe = {
+  id: "44444444-4444-4444-8444-444444444444",
+  name: "WBHQ",
+  isEnabled: true,
+};
+
+const DISABLED_PROBE: AttachedProbe = {
+  id: "55555555-5555-4555-8555-555555555555",
+  name: "Retired Probe",
+  isEnabled: false,
+};
+
+describe("MonitorSummaryProbeUtil.resolveSelectedProbeId", () => {
+  it("returns null when the monitor has no probes attached", () => {
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({ probes: [] }),
+    ).toBeNull();
+  });
+
+  it("returns null for a missing probe list rather than throwing", () => {
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: undefined as unknown as Array<AttachedProbe>,
+      }),
+    ).toBeNull();
+  });
+
+  it("selects the first probe when nothing is selected yet", () => {
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [CUSTOM_PROBE, GLOBAL_PROBE],
+      }),
+    ).toBe(CUSTOM_PROBE.id);
+  });
+
+  it("keeps the probe the user picked when the list is handed down again", () => {
+    /*
+     * The effect that calls this re-runs on every new probes array. Resetting
+     * to the first entry there is indistinguishable, to a user, from a
+     * selection that refuses to stick.
+     */
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [CUSTOM_PROBE, GLOBAL_PROBE],
+        currentlySelectedProbeId: GLOBAL_PROBE.id,
+      }),
+    ).toBe(GLOBAL_PROBE.id);
+  });
+
+  it("keeps the selection even when that probe has since been disabled", () => {
+    // The user asked to look at it; showing something else would be surprising.
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [GLOBAL_PROBE, DISABLED_PROBE],
+        currentlySelectedProbeId: DISABLED_PROBE.id,
+      }),
+    ).toBe(DISABLED_PROBE.id);
+  });
+
+  it("falls back when the selected probe has been detached from the monitor", () => {
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [GLOBAL_PROBE],
+        currentlySelectedProbeId: CUSTOM_PROBE.id,
+      }),
+    ).toBe(GLOBAL_PROBE.id);
+  });
+
+  it("prefers an enabled probe over a disabled one when defaulting", () => {
+    /*
+     * A disabled probe has nothing to show, so opening the card on one reads
+     * as broken even though everything is working as configured.
+     */
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [DISABLED_PROBE, GLOBAL_PROBE],
+      }),
+    ).toBe(GLOBAL_PROBE.id);
+  });
+
+  it("still selects something when every attached probe is disabled", () => {
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [DISABLED_PROBE],
+      }),
+    ).toBe(DISABLED_PROBE.id);
+  });
+
+  it("ignores rows with no id, which cannot be selected", () => {
+    const noId: AttachedProbe = { id: "", name: "Broken", isEnabled: true };
+
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [noId, GLOBAL_PROBE],
+      }),
+    ).toBe(GLOBAL_PROBE.id);
+  });
+
+  it("treats an empty currently-selected id as no selection", () => {
+    expect(
+      MonitorSummaryProbeUtil.resolveSelectedProbeId({
+        probes: [DISABLED_PROBE, GLOBAL_PROBE],
+        currentlySelectedProbeId: "",
+      }),
+    ).toBe(GLOBAL_PROBE.id);
+  });
+});
+
+describe("MonitorSummaryProbeUtil.getProbeDropdownOptions", () => {
+  it("offers exactly the probes it is given, in order", () => {
+    /*
+     * The whole defect: the picker used to be handed every probe in the
+     * project. It can only ever offer what actually monitors this resource.
+     */
+    expect(
+      MonitorSummaryProbeUtil.getProbeDropdownOptions({
+        probes: [GLOBAL_PROBE, CUSTOM_PROBE],
+      }),
+    ).toEqual([
+      { label: "Probe", value: GLOBAL_PROBE.id },
+      { label: "WBHQ", value: CUSTOM_PROBE.id },
+    ]);
+  });
+
+  it("marks a disabled probe so its empty summary is explained", () => {
+    expect(
+      MonitorSummaryProbeUtil.getProbeDropdownOptions({
+        probes: [DISABLED_PROBE],
+      }),
+    ).toEqual([
+      { label: "Retired Probe (disabled)", value: DISABLED_PROBE.id },
+    ]);
+  });
+
+  it("falls back to a placeholder name rather than rendering an empty option", () => {
+    expect(
+      MonitorSummaryProbeUtil.getProbeDropdownOptions({
+        probes: [{ id: GLOBAL_PROBE.id, name: "", isEnabled: true }],
+      }),
+    ).toEqual([{ label: "Unknown", value: GLOBAL_PROBE.id }]);
+  });
+
+  it("drops rows with no id, which would produce an unselectable option", () => {
+    expect(
+      MonitorSummaryProbeUtil.getProbeDropdownOptions({
+        probes: [{ id: "", name: "Broken", isEnabled: true }, GLOBAL_PROBE],
+      }),
+    ).toEqual([{ label: "Probe", value: GLOBAL_PROBE.id }]);
+  });
+
+  it("returns nothing for a monitor with no probes", () => {
+    expect(
+      MonitorSummaryProbeUtil.getProbeDropdownOptions({ probes: [] }),
+    ).toEqual([]);
+  });
+});
+
+describe("MonitorSummaryProbeUtil.getProbeState", () => {
+  it("reports results whenever there is anything to render", () => {
+    expect(
+      MonitorSummaryProbeUtil.getProbeState({
+        isProbeableMonitor: true,
+        attachedProbeCount: 1,
+        isSelectedProbeEnabled: true,
+        probeResponseCount: 1,
+      }),
+    ).toBe(MonitorSummaryProbeState.HasResults);
+  });
+
+  it("prefers showing results over any empty-state explanation", () => {
+    /*
+     * A probe switched off after it reported still has data worth looking at.
+     */
+    expect(
+      MonitorSummaryProbeUtil.getProbeState({
+        isProbeableMonitor: true,
+        attachedProbeCount: 1,
+        isSelectedProbeEnabled: false,
+        probeResponseCount: 2,
+      }),
+    ).toBe(MonitorSummaryProbeState.HasResults);
+  });
+
+  it("says nothing is monitoring the resource when no probe is attached", () => {
+    // Not "wait a few minutes" - waiting will never help.
+    expect(
+      MonitorSummaryProbeUtil.getProbeState({
+        isProbeableMonitor: true,
+        attachedProbeCount: 0,
+        isSelectedProbeEnabled: true,
+        probeResponseCount: 0,
+      }),
+    ).toBe(MonitorSummaryProbeState.NoProbesAttached);
+  });
+
+  it("says the probe is switched off when it is attached but disabled", () => {
+    expect(
+      MonitorSummaryProbeUtil.getProbeState({
+        isProbeableMonitor: true,
+        attachedProbeCount: 1,
+        isSelectedProbeEnabled: false,
+        probeResponseCount: 0,
+      }),
+    ).toBe(MonitorSummaryProbeState.SelectedProbeDisabled);
+  });
+
+  it("asks the user to wait only when waiting is actually the answer", () => {
+    expect(
+      MonitorSummaryProbeUtil.getProbeState({
+        isProbeableMonitor: true,
+        attachedProbeCount: 1,
+        isSelectedProbeEnabled: true,
+        probeResponseCount: 0,
+      }),
+    ).toBe(MonitorSummaryProbeState.AwaitingFirstResult);
+  });
+
+  it("does not blame probes on a monitor type that has none", () => {
+    /*
+     * Server, incoming-request and telemetry monitors are not watched by
+     * probes at all, so "no probes are monitoring this resource" would be
+     * nonsense there.
+     */
+    expect(
+      MonitorSummaryProbeUtil.getProbeState({
+        isProbeableMonitor: false,
+        attachedProbeCount: 0,
+        isSelectedProbeEnabled: true,
+        probeResponseCount: 0,
+      }),
+    ).toBe(MonitorSummaryProbeState.AwaitingFirstResult);
+  });
+});