@oneuptime/common 12.0.5 → 12.0.7

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

@@ -0,0 +1,165 @@
+import DataSourceQueryText from "../../../Utils/DataSource/DataSourceQueryText";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+import { describe, expect, test } from "@jest/globals";
+
+function makeVariable(
+  overrides: Partial<DashboardVariable>,
+): DashboardVariable {
+  return {
+    id: "var-1",
+    name: "cluster",
+    type: DashboardVariableType.CustomList,
+    ...overrides,
+  } as DashboardVariable;
+}
+
+describe("DataSourceQueryText.applyVariables", () => {
+  test("replaces a scalar variable", () => {
+    const result: string = DataSourceQueryText.applyVariables(
+      'up{cluster="{{cluster}}"}',
+      [makeVariable({ selectedValue: "prod" })],
+    );
+    expect(result).toBe('up{cluster="prod"}');
+  });
+
+  test("replaces every occurrence and tolerates inner whitespace", () => {
+    const result: string = DataSourceQueryText.applyVariables(
+      "{{ cluster }} and {{cluster}}",
+      [makeVariable({ selectedValue: "prod" })],
+    );
+    expect(result).toBe("prod and prod");
+  });
+
+  test("joins multi-select values with | for regex matchers", () => {
+    const result: string = DataSourceQueryText.applyVariables(
+      'up{cluster=~"{{cluster}}"}',
+      [
+        makeVariable({
+          isMultiSelect: true,
+          selectedValues: ["prod", "staging"],
+        }),
+      ],
+    );
+    expect(result).toBe('up{cluster=~"prod|staging"}');
+  });
+
+  test("falls back to defaultValue when nothing is selected", () => {
+    const result: string = DataSourceQueryText.applyVariables("{{cluster}}", [
+      makeVariable({ defaultValue: "default-cluster" }),
+    ]);
+    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({}),
+    ]);
+    expect(result).toBe("{{cluster}}");
+  });
+
+  test("leaves unknown tokens untouched", () => {
+    const result: string = DataSourceQueryText.applyVariables("{{unknown}}", [
+      makeVariable({ selectedValue: "prod" }),
+    ]);
+    expect(result).toBe("{{unknown}}");
+  });
+
+  test("returns query untouched with no variables", () => {
+    expect(DataSourceQueryText.applyVariables("SELECT 1", undefined)).toBe(
+      "SELECT 1",
+    );
+    expect(DataSourceQueryText.applyVariables("SELECT 1", [])).toBe("SELECT 1");
+  });
+
+  test("escapes regex metacharacters in variable names", () => {
+    const result: string = DataSourceQueryText.applyVariables(
+      "{{a.b}} stays, {{acb}} stays too",
+      [makeVariable({ name: "a.b", selectedValue: "X" })],
+    );
+    /*
+     * A "." in the variable name must NOT act as a regex wildcard —
+     * only the literal {{a.b}} token is replaced.
+     */
+    expect(result).toBe("X stays, {{acb}} stays too");
+  });
+
+  test("handles multiple variables in one query", () => {
+    const result: string = DataSourceQueryText.applyVariables(
+      "SELECT * FROM t WHERE env = '{{env}}' AND region = '{{region}}'",
+      [
+        makeVariable({ name: "env", selectedValue: "prod" }),
+        makeVariable({ id: "var-2", name: "region", selectedValue: "eu-1" }),
+      ],
+    );
+    expect(result).toBe(
+      "SELECT * FROM t WHERE env = 'prod' AND region = 'eu-1'",
+    );
+  });
+});
+
+describe("DataSourceQueryText.applyLegendTemplate", () => {
+  test("substitutes attribute values", () => {
+    const result: string = DataSourceQueryText.applyLegendTemplate(
+      "{{instance}} ({{job}})",
+      { instance: "api-1:9090", job: "api" },
+    );
+    expect(result).toBe("api-1:9090 (api)");
+  });
+
+  test("renders (unset) for missing or empty attributes", () => {
+    expect(
+      DataSourceQueryText.applyLegendTemplate("{{missing}}", { a: "b" }),
+    ).toBe("(unset)");
+    expect(
+      DataSourceQueryText.applyLegendTemplate("{{empty}}", { empty: "" }),
+    ).toBe("(unset)");
+    expect(DataSourceQueryText.applyLegendTemplate("{{a}}", undefined)).toBe(
+      "(unset)",
+    );
+  });
+
+  test("returns template untouched when it has no placeholders", () => {
+    expect(
+      DataSourceQueryText.applyLegendTemplate("Errors per second", {
+        a: "b",
+      }),
+    ).toBe("Errors per second");
+  });
+
+  test("tolerates whitespace inside placeholders", () => {
+    expect(
+      DataSourceQueryText.applyLegendTemplate("{{ instance }}", {
+        instance: "web-1",
+      }),
+    ).toBe("web-1");
+  });
+});