@oneuptime/common 12.0.6 → 12.0.8

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({}),

package/Tests/Utils/LegacySerializedArray.test.ts

@@ -0,0 +1,139 @@
+import { readLegacySerializedArray } from "../../Utils/LegacySerializedArray";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The pre-fix serializer turned an array it received directly into a
+ * numeric-keyed object. Values written that way are still in databases and in
+ * browser local storage, so both shapes have to read back — while a genuine
+ * object that merely happens to carry a "0" key must not be mistaken for one
+ * of them.
+ */
+
+describe("readLegacySerializedArray", () => {
+  describe("Values that are already arrays", () => {
+    test("Returns an array unchanged", () => {
+      expect(readLegacySerializedArray(["time", "body"])).toEqual([
+        "time",
+        "body",
+      ]);
+    });
+
+    test("Returns an empty array unchanged", () => {
+      expect(readLegacySerializedArray([])).toEqual([]);
+    });
+
+    test("Leaves element types alone", () => {
+      const mixed: Array<unknown> = [1, "x", null, { a: 1 }, ["nested"]];
+
+      expect(readLegacySerializedArray(mixed)).toEqual(mixed);
+    });
+
+    test("Returns the same reference, not a copy", () => {
+      const original: Array<unknown> = ["time"];
+
+      expect(readLegacySerializedArray(original)).toBe(original);
+    });
+  });
+
+  describe("Values corrupted into numeric-keyed objects", () => {
+    test("Rebuilds a two-element array", () => {
+      expect(readLegacySerializedArray({ "0": "service", "1": "api" })).toEqual(
+        ["service", "api"],
+      );
+    });
+
+    test("Rebuilds a longer array in index order", () => {
+      expect(
+        readLegacySerializedArray({
+          "0": "time",
+          "1": "body",
+          "2": "severityText",
+        }),
+      ).toEqual(["time", "body", "severityText"]);
+    });
+
+    test("Rebuilds in index order even when the keys are out of order", () => {
+      expect(
+        readLegacySerializedArray({
+          "2": "third",
+          "0": "first",
+          "1": "second",
+        }),
+      ).toEqual(["first", "second", "third"]);
+    });
+
+    test("Rebuilds a single-element array", () => {
+      expect(readLegacySerializedArray({ "0": "only" })).toEqual(["only"]);
+    });
+
+    test("Keeps null and empty-string elements", () => {
+      expect(readLegacySerializedArray({ "0": null, "1": "" })).toEqual([
+        null,
+        "",
+      ]);
+    });
+
+    test("Reads an empty object as an empty array", () => {
+      // An empty array is exactly what the old serializer wrote as {}.
+      expect(readLegacySerializedArray({})).toEqual([]);
+    });
+
+    test("The result is a real array, so it can be destructured", () => {
+      const restored: Array<unknown> | null = readLegacySerializedArray({
+        "0": "service",
+        "1": "api",
+      });
+
+      expect(Array.isArray(restored)).toBe(true);
+      expect(() => {
+        const [first]: Array<unknown> = restored as Array<unknown>;
+        return first;
+      }).not.toThrow();
+    });
+  });
+
+  describe("Values that are not arrays in any shape", () => {
+    test("Rejects null and undefined", () => {
+      expect(readLegacySerializedArray(null)).toBeNull();
+      expect(readLegacySerializedArray(undefined)).toBeNull();
+    });
+
+    test("Rejects primitives", () => {
+      expect(readLegacySerializedArray("time")).toBeNull();
+      expect(readLegacySerializedArray(7)).toBeNull();
+      expect(readLegacySerializedArray(true)).toBeNull();
+    });
+
+    test("Rejects a plain object with named keys", () => {
+      expect(readLegacySerializedArray({ facetKey: "service" })).toBeNull();
+    });
+
+    test("Rejects an object that only partly looks like an array", () => {
+      // "0" is there but "1" is not, so the run of indices is incomplete.
+      expect(
+        readLegacySerializedArray({ "0": "service", foo: "bar" }),
+      ).toBeNull();
+    });
+
+    test("Rejects an object whose indices do not start at zero", () => {
+      expect(readLegacySerializedArray({ "1": "a", "2": "b" })).toBeNull();
+    });
+
+    test("Rejects an object with a gap in its indices", () => {
+      expect(readLegacySerializedArray({ "0": "a", "2": "b" })).toBeNull();
+    });
+
+    test("Rejects a real saved-view state object", () => {
+      /*
+       * Guards the boundary the other way: a JSON column's own object must
+       * never be read as a list of its values.
+       */
+      expect(
+        readLegacySerializedArray({
+          search: "status:error",
+          pageSize: 50,
+        }),
+      ).toBeNull();
+    });
+  });
+});