@oneuptime/common 12.0.6 → 12.0.7

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

@@ -0,0 +1,72 @@
+import LocalStorage from "../../../UI/Utils/LocalStorage";
+import { readLegacySerializedArray } from "../../../Utils/LegacySerializedArray";
+import { beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * LocalStorage.setItem hands the caller's value straight to
+ * JSONFunctions.serializeValue rather than wrapping it in an object first, so
+ * a TOP-LEVEL array took the same broken path as a nested one and came back as
+ * { "0": ..., "1": ... }. This is not the saved-view case: the array is flat.
+ *
+ * It shipped. The logs explorer stores its selected columns here, read back
+ * behind an Array.isArray guard, so the corruption showed up as the column
+ * picker silently resetting to defaults on every reload — no error anywhere.
+ */
+
+describe("LocalStorage round-trips arrays", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  test("A flat string array comes back as an array", () => {
+    LocalStorage.setItem("columns", ["time", "body", "severityText"]);
+
+    const restored: unknown = LocalStorage.getItem("columns");
+
+    expect(Array.isArray(restored)).toBe(true);
+    expect(restored).toEqual(["time", "body", "severityText"]);
+  });
+
+  test("The stored JSON is an array, not a numeric-keyed object", () => {
+    LocalStorage.setItem("columns", ["time", "body"]);
+
+    expect(localStorage.getItem("columns")).toBe('["time","body"]');
+  });
+
+  test("An empty array round-trips", () => {
+    LocalStorage.setItem("columns", []);
+
+    expect(LocalStorage.getItem("columns")).toEqual([]);
+  });
+
+  test("An array of numbers round-trips", () => {
+    LocalStorage.setItem("sizes", [10, 25, 50]);
+
+    expect(LocalStorage.getItem("sizes")).toEqual([10, 25, 50]);
+  });
+
+  test("An array nested inside a stored object round-trips", () => {
+    LocalStorage.setItem("state", { columns: ["time"], filters: [["a", "b"]] });
+
+    expect(LocalStorage.getItem("state")).toEqual({
+      columns: ["time"],
+      filters: [["a", "b"]],
+    });
+  });
+
+  test("A plain object is still stored as an object", () => {
+    LocalStorage.setItem("prefs", { pageSize: 50 });
+
+    expect(LocalStorage.getItem("prefs")).toEqual({ pageSize: 50 });
+  });
+
+  test("A value written by the old serializer still reads back as a list", () => {
+    // What a pre-fix build left in the browser.
+    localStorage.setItem("columns", '{"0":"time","1":"body"}');
+
+    const restored: unknown = LocalStorage.getItem("columns");
+
+    expect(Array.isArray(restored)).toBe(false);
+    expect(readLegacySerializedArray(restored)).toEqual(["time", "body"]);
+  });
+});

package/Tests/Utils/Dashboard/HtmlWidgetDocument.test.ts

@@ -216,7 +216,12 @@ describe("HtmlWidgetDocument", () => {
       ).toEqual({ clusters: "eu-1,us-1" });
     });
 
-    it("falls back to the default when a multi-select has no picks", () => {
+    /*
+     * A multi-select with no picks is "All", and the default does not
+     * override it — same rule the chart widgets follow. The author sees
+     * an empty string, which is what "no scope" looks like in a template.
+     */
+    it("renders an empty string when a multi-select has no picks", () => {
       expect(
         HtmlWidgetDocument.resolveVariables([
           makeVariable({
@@ -226,7 +231,19 @@ describe("HtmlWidgetDocument", () => {
             defaultValue: "eu-1",
           }),
         ]),
-      ).toEqual({ clusters: "eu-1" });
+      ).toEqual({ clusters: "" });
+    });
+
+    it("renders an empty string for an untouched multi-select with a default", () => {
+      expect(
+        HtmlWidgetDocument.resolveVariables([
+          makeVariable({
+            name: "clusters",
+            isMultiSelect: true,
+            defaultValue: "eu-1",
+          }),
+        ]),
+      ).toEqual({ clusters: "" });
     });
 
     it("maps an unset variable to an empty string rather than dropping it", () => {

package/Tests/Utils/Dashboard/ModelQueryVariableInterpolation.test.ts

@@ -105,6 +105,50 @@ describe("DashboardModelQueryInterpolation.applyToQuery - writing predicates", (
     expect((result["hostname"] as Includes).values).toEqual(["web1", "web2"]);
   });
 
+  /*
+   * Resource list widgets share DashboardVariableInterpolation.resolveValue
+   * with the metric widgets, so they inherit the "All" rule: an empty
+   * multi-select filters nothing, and the variable's single-select Default
+   * does not stand in for the picks the user did not make.
+   */
+  test("an empty multi-select writes no predicate, Default or not", () => {
+    const query: Record<string, unknown> = { kind: "Container" };
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        query,
+        [
+          attrVariable("host.name", {
+            isMultiSelect: true,
+            selectedValues: [],
+            defaultValue: "web1",
+          }),
+        ],
+        MAP,
+      );
+
+    expect(result).toBe(query);
+    expect(result["hostname"]).toBeUndefined();
+  });
+
+  test("a cleared multi-select removes a prior filter on that column", () => {
+    const query: Record<string, unknown> = { hostname: "web1", kind: "Pod" };
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        query,
+        [
+          attrVariable("host.name", {
+            isMultiSelect: true,
+            selectedValues: [],
+            defaultValue: "web1",
+          }),
+        ],
+        MAP,
+      );
+
+    expect(result).toEqual({ kind: "Pod" });
+    expect(query).toEqual({ hostname: "web1", kind: "Pod" }); // input untouched
+  });
+
   test("maps two variables onto their respective columns", () => {
     const result: Record<string, unknown> =
       DashboardModelQueryInterpolation.applyToQuery(

package/Tests/Utils/Dashboard/VariableInterpolation.test.ts

@@ -2,6 +2,7 @@ import Includes from "../../../Types/BaseDatabase/Includes";
 import DashboardVariable, {
   DashboardVariableType,
 } from "../../../Types/Dashboard/DashboardVariable";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
 import DashboardVariableInterpolation from "../../../Utils/Dashboard/VariableInterpolation";
 
 function makeVariable(
@@ -15,6 +16,24 @@ function makeVariable(
   } as DashboardVariable;
 }
 
+function makeQueryConfig(
+  attributes: Record<string, unknown> | undefined,
+): MetricQueryConfigData {
+  return {
+    metricQueryData: {
+      filterData: attributes === undefined ? {} : { attributes },
+    },
+  } as unknown as MetricQueryConfigData;
+}
+
+function attributesOf(
+  config: MetricQueryConfigData,
+): Record<string, unknown> | undefined {
+  return config.metricQueryData.filterData.attributes as unknown as
+    | Record<string, unknown>
+    | undefined;
+}
+
 describe("DashboardVariableInterpolation", () => {
   describe("resolveValue", () => {
     test("returns scalar for a single-select with selectedValue", () => {
@@ -76,14 +95,117 @@ describe("DashboardVariableInterpolation", () => {
       });
     });
 
-    test("multi-select with no picks falls through to scalar default", () => {
+    /*
+     * The contract for multi-select, and the reason it is not simply
+     * "reuse the single-select fallback": the selector renders "All"
+     * whenever `selectedValues` is empty and has no way to render
+     * anything else. If an empty list resolved to `defaultValue`, every
+     * multi-select variable with a Default would filter its widgets from
+     * behind a control that says the widgets are unfiltered — and the
+     * popover's own Clear button is the fastest way to get there.
+     */
+    describe("an empty multi-select means All", () => {
+      test("ignores defaultValue when the list is empty", () => {
+        const variable: DashboardVariable = makeVariable({
+          isMultiSelect: true,
+          selectedValues: [],
+          defaultValue: "d",
+        });
+        expect(
+          DashboardVariableInterpolation.resolveValue(variable),
+        ).toBeUndefined();
+      });
+
+      test("ignores defaultValue when the list is unset", () => {
+        const variable: DashboardVariable = makeVariable({
+          isMultiSelect: true,
+          defaultValue: "d",
+        });
+        expect(
+          DashboardVariableInterpolation.resolveValue(variable),
+        ).toBeUndefined();
+      });
+
+      test("ignores defaultValue when every pick is blank", () => {
+        const variable: DashboardVariable = makeVariable({
+          isMultiSelect: true,
+          selectedValues: ["", ""],
+          defaultValue: "d",
+        });
+        expect(
+          DashboardVariableInterpolation.resolveValue(variable),
+        ).toBeUndefined();
+      });
+
+      /*
+       * A variable that was single-select before the author ticked
+       * "Allow multi-select" still carries the scalar it was left on.
+       * The multi list is the only source of truth once the flag is set,
+       * so that stale scalar must not resurface as a filter.
+       */
+      test("ignores a stale selectedValue left over from single-select", () => {
+        const variable: DashboardVariable = makeVariable({
+          isMultiSelect: true,
+          selectedValues: [],
+          selectedValue: "stale",
+          defaultValue: "d",
+        });
+        expect(
+          DashboardVariableInterpolation.resolveValue(variable),
+        ).toBeUndefined();
+      });
+
+      test("still resolves once the user picks something", () => {
+        const variable: DashboardVariable = makeVariable({
+          isMultiSelect: true,
+          selectedValues: ["a"],
+          defaultValue: "d",
+        });
+        expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+          multi: ["a"],
+        });
+      });
+    });
+
+    /*
+     * The mirror of the rule above on the single-select side. "" is the
+     * value of the selector's "All" option — a real choice — so it must
+     * not fall back to the default. `??` draws that line; `||` would not.
+     */
+    test("an explicit empty scalar is All, not a fallback to the default", () => {
       const variable: DashboardVariable = makeVariable({
-        isMultiSelect: true,
-        selectedValues: [],
-        defaultValue: "d",
+        selectedValue: "",
+        defaultValue: "staging",
+      });
+      expect(
+        DashboardVariableInterpolation.resolveValue(variable),
+      ).toBeUndefined();
+    });
+
+    test("defaultValue still applies to a single-select that is untouched", () => {
+      expect(
+        DashboardVariableInterpolation.resolveValue(
+          makeVariable({ defaultValue: "staging", isMultiSelect: false }),
+        ),
+      ).toEqual({ scalar: "staging" });
+    });
+
+    test("an empty defaultValue is not a filter", () => {
+      expect(
+        DashboardVariableInterpolation.resolveValue(
+          makeVariable({ defaultValue: "" }),
+        ),
+      ).toBeUndefined();
+    });
+
+    test("selectedValues on a single-select variable is ignored", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: false,
+        selectedValues: ["a", "b"],
+        selectedValue: "prod",
       });
       expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
-        scalar: "d",
+        scalar: "prod",
       });
     });
   });
@@ -178,6 +300,74 @@ describe("DashboardVariableInterpolation", () => {
       expect(result).toEqual({ "k8s.cluster.name": "prod" });
     });
 
+    /*
+     * The user-visible bug this contract exists for: the popover reads
+     * "All" the moment the last pick is removed, so the widget has to be
+     * unfiltered at that moment too — including dropping the widget's own
+     * base filter on that key, exactly as an "All" single-select does.
+     */
+    test("a cleared multi-select with a default removes the filter", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        isMultiSelect: true,
+        selectedValues: [],
+        defaultValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(
+          { "k8s.cluster.name": "staging", other: "keep" },
+          [variable],
+        );
+      expect(result).toEqual({ other: "keep" });
+    });
+
+    test("a cleared multi-select with a default adds nothing", () => {
+      const attrs: Record<string, unknown> = { other: "keep" };
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        isMultiSelect: true,
+        selectedValues: [],
+        defaultValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]);
+      expect(result).toBe(attrs);
+      expect(result["k8s.cluster.name"]).toBeUndefined();
+    });
+
+    test("an untouched multi-select with a default adds nothing", () => {
+      const attrs: Record<string, unknown> = {};
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        isMultiSelect: true,
+        defaultValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("clearing one multi-select does not disturb another variable", () => {
+      const cleared: DashboardVariable = makeVariable({
+        id: "v1",
+        attributeKey: "cluster",
+        isMultiSelect: true,
+        selectedValues: [],
+        defaultValue: "prod",
+      });
+      const picked: DashboardVariable = makeVariable({
+        id: "v2",
+        attributeKey: "namespace",
+        selectedValue: "default",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(
+          { cluster: "staging" },
+          [cleared, picked],
+        );
+      expect(result).toEqual({ namespace: "default" });
+    });
+
     test("applies multiple variables at once", () => {
       const v1: DashboardVariable = makeVariable({
         id: "v1",
@@ -194,4 +384,97 @@ describe("DashboardVariableInterpolation", () => {
       expect(result).toEqual({ cluster: "prod", namespace: "default" });
     });
   });
+
+  /*
+   * Metric charts and gauges go through the query-config wrapper rather
+   * than calling applyToAttributes directly, so the "All" contract is
+   * pinned at that level too — this is the path a user actually watches
+   * change when they clear the popover.
+   */
+  describe("applyToQueryConfig", () => {
+    test("injects an Includes for a multi-select with picks", () => {
+      const config: MetricQueryConfigData = makeQueryConfig({});
+      const result: MetricQueryConfigData =
+        DashboardVariableInterpolation.applyToQueryConfig(config, [
+          makeVariable({
+            attributeKey: "k8s.cluster.name",
+            isMultiSelect: true,
+            selectedValues: ["eu-1", "us-1"],
+          }),
+        ]);
+      const value: unknown = attributesOf(result)?.["k8s.cluster.name"];
+      expect(value).toBeInstanceOf(Includes);
+      expect((value as Includes).values).toEqual(["eu-1", "us-1"]);
+    });
+
+    test("a cleared multi-select with a default leaves the query unfiltered", () => {
+      const config: MetricQueryConfigData = makeQueryConfig({
+        "k8s.cluster.name": "prod",
+      });
+      const result: MetricQueryConfigData =
+        DashboardVariableInterpolation.applyToQueryConfig(config, [
+          makeVariable({
+            attributeKey: "k8s.cluster.name",
+            isMultiSelect: true,
+            selectedValues: [],
+            defaultValue: "prod",
+          }),
+        ]);
+      expect(attributesOf(result)).toEqual({});
+    });
+
+    test("returns the same config reference when nothing changes", () => {
+      const config: MetricQueryConfigData = makeQueryConfig({});
+      expect(
+        DashboardVariableInterpolation.applyToQueryConfig(config, [
+          makeVariable({
+            attributeKey: "k8s.cluster.name",
+            isMultiSelect: true,
+            selectedValues: [],
+            defaultValue: "prod",
+          }),
+        ]),
+      ).toBe(config);
+      expect(
+        DashboardVariableInterpolation.applyToQueryConfig(config, []),
+      ).toBe(config);
+      expect(
+        DashboardVariableInterpolation.applyToQueryConfig(config, undefined),
+      ).toBe(config);
+    });
+
+    test("leaves a config with no filterData alone", () => {
+      const config: MetricQueryConfigData = {
+        metricQueryData: {},
+      } as unknown as MetricQueryConfigData;
+      expect(
+        DashboardVariableInterpolation.applyToQueryConfig(config, [
+          makeVariable({
+            attributeKey: "k8s.cluster.name",
+            selectedValue: "prod",
+          }),
+        ]),
+      ).toBe(config);
+    });
+
+    test("applyToQueryConfigs maps every config", () => {
+      const configs: Array<MetricQueryConfigData> = [
+        makeQueryConfig({ "k8s.cluster.name": "prod" }),
+        makeQueryConfig({ "k8s.cluster.name": "prod", keep: "me" }),
+      ];
+      const result: Array<MetricQueryConfigData> =
+        DashboardVariableInterpolation.applyToQueryConfigs(configs, [
+          makeVariable({
+            attributeKey: "k8s.cluster.name",
+            isMultiSelect: true,
+            selectedValues: [],
+            defaultValue: "prod",
+          }),
+        ]);
+      expect(attributesOf(result[0] as MetricQueryConfigData)).toEqual({});
+      expect(attributesOf(result[1] as MetricQueryConfigData)).toEqual({
+        keep: "me",
+      });
+    });
+  });
 });

package/Tests/Utils/Dashboard/VariableUrlState.test.ts

@@ -4,6 +4,7 @@ import DashboardVariableUrlState, {
 import DashboardVariable, {
   DashboardVariableType,
 } from "../../../Types/Dashboard/DashboardVariable";
+import DashboardVariableInterpolation from "../../../Utils/Dashboard/VariableInterpolation";
 
 function makeVariable(data: Partial<DashboardVariable>): DashboardVariable {
   return {
@@ -147,6 +148,47 @@ describe("DashboardVariableUrlState", () => {
       expect(applied[0]?.selectedValue).toBe("prod");
       expect(applied[1]?.selectedValues).toEqual(["us", "eu"]);
     });
+
+    /*
+     * "All" is the absence of a var- param — writeToBrowserUrl emits
+     * nothing for an empty selection, so a reload cannot tell "cleared"
+     * from "never touched" and must treat both as All. That only holds
+     * because resolveValue ignores defaultValue for a multi-select; if it
+     * fell back, a viewer who cleared the popover would silently get the
+     * author's Default back on every refresh and on every shared link.
+     */
+    test("a cleared multi-select survives a url round trip as All", () => {
+      window.history.replaceState({}, "", "/dashboard");
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({
+          name: "region",
+          isMultiSelect: true,
+          selectedValues: [],
+          defaultValue: "us",
+        }),
+      ]);
+
+      expect(window.location.search).toBe("");
+
+      const applied: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables(
+          [
+            makeVariable({
+              name: "region",
+              isMultiSelect: true,
+              defaultValue: "us",
+            }),
+          ],
+          DashboardVariableUrlState.parseFromSearch(window.location.search),
+        );
+
+      expect(applied[0]?.selectedValues).toBeUndefined();
+      expect(
+        DashboardVariableInterpolation.resolveValue(
+          applied[0] as DashboardVariable,
+        ),
+      ).toBeUndefined();
+    });
   });
 
   describe("writeToBrowserUrl", () => {

package/Tests/Utils/DataSource/DataSourceQueryText.test.ts

@@ -52,6 +52,33 @@ describe("DataSourceQueryText.applyVariables", () => {
     expect(result).toBe("default-cluster");
   });
 
+  /*
+   * An empty multi-select is "All", so it resolves to nothing and the token
+   * is left standing — the connector then names the unbound variable
+   * instead of silently querying the author's Default, which is a
+   * single-select concept the picks were never seeded from.
+   */
+  test("an empty multi-select leaves the token untouched, Default or not", () => {
+    const result: string = DataSourceQueryText.applyVariables(
+      'up{cluster=~"{{cluster}}"}',
+      [
+        makeVariable({
+          isMultiSelect: true,
+          selectedValues: [],
+          defaultValue: "prod",
+        }),
+      ],
+    );
+    expect(result).toBe('up{cluster=~"{{cluster}}"}');
+  });
+
+  test("an untouched multi-select leaves the token untouched too", () => {
+    const result: string = DataSourceQueryText.applyVariables("{{cluster}}", [
+      makeVariable({ isMultiSelect: true, defaultValue: "prod" }),
+    ]);
+    expect(result).toBe("{{cluster}}");
+  });
+
   test("leaves the token untouched when the variable is unresolved", () => {
     const result: string = DataSourceQueryText.applyVariables("{{cluster}}", [
       makeVariable({}),