@oneuptime/common 12.0.34 → 13.0.0

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

@@ -0,0 +1,257 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesAnyOfGroups from "../../../Types/BaseDatabase/IncludesAnyOfGroups";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+import JSONFunctions from "../../../Types/JSONFunctions";
+import DashboardLabelVariable from "../../../Utils/Dashboard/LabelVariable";
+
+const UNIT_660: string = "06600000-0000-4000-8000-000000000000";
+const UNIT_661: string = "06610000-0000-4000-8000-000000000000";
+const NETWORK: string = "00000000-0000-4000-8000-000000000001";
+
+function variable(
+  overrides: Partial<DashboardVariable> = {},
+): DashboardVariable {
+  return {
+    id: "unit",
+    name: "UNIT",
+    type: DashboardVariableType.ProjectLabel,
+    labelOptions: [
+      { label: "0660", value: UNIT_660 },
+      { label: "0661", value: UNIT_661 },
+    ],
+    ...overrides,
+  };
+}
+
+function filter(
+  overrides: Partial<DashboardVariable> = {},
+  labelIds?: Array<string>,
+): ReturnType<typeof DashboardLabelVariable.getFilter> {
+  return DashboardLabelVariable.getFilter({
+    labelVariableId: "unit",
+    labelIds,
+    variables: [variable(overrides)],
+  });
+}
+
+describe("project label dashboard variable filters", () => {
+  test("keeps existing widgets with fixed labels unchanged", () => {
+    expect(DashboardLabelVariable.getFilter({ labelIds: [NETWORK] })).toEqual(
+      new Includes([NETWORK]),
+    );
+    expect(DashboardLabelVariable.getFilter({})).toBeUndefined();
+  });
+
+  test("a title or an unbound variable does not change the query", () => {
+    expect(
+      DashboardLabelVariable.getFilter({
+        variables: [variable({ selectedValue: UNIT_660 })],
+      }),
+    ).toBeUndefined();
+  });
+
+  test.each([UNIT_660, UNIT_661])(
+    "filters by selected label ID %s",
+    (id: string) => {
+      expect(filter({ selectedValue: id })).toEqual(new Includes([id]));
+    },
+  );
+
+  test("uses an absent selection's default", () => {
+    expect(filter({ defaultValue: UNIT_660 })).toEqual(
+      new Includes([UNIT_660]),
+    );
+  });
+
+  test("All overrides a default and retains the fixed label condition", () => {
+    expect(
+      filter({ defaultValue: UNIT_660, selectedValue: "" }, [NETWORK]),
+    ).toEqual(new Includes([NETWORK]));
+    expect(filter({ selectedValue: "" })).toBeUndefined();
+  });
+
+  test("multi-select is OR within units and AND with fixed labels", () => {
+    expect(
+      filter({ isMultiSelect: true, selectedValues: [UNIT_660, UNIT_661] }, [
+        NETWORK,
+      ]),
+    ).toEqual(new IncludesAnyOfGroups([[NETWORK], [UNIT_660, UNIT_661]]));
+  });
+
+  test("empty multi-select ignores a stale scalar and default", () => {
+    expect(
+      filter(
+        {
+          isMultiSelect: true,
+          selectedValues: [],
+          selectedValue: UNIT_660,
+          defaultValue: UNIT_661,
+        },
+        [NETWORK],
+      ),
+    ).toEqual(new Includes([NETWORK]));
+  });
+
+  test("does not mutate saved configuration and deduplicates repeated picks", () => {
+    const saved: DashboardVariable = variable({
+      isMultiSelect: true,
+      selectedValues: [UNIT_660, UNIT_660],
+    });
+    const before: string = JSON.stringify(saved);
+    const fixed: Array<string> = [NETWORK, NETWORK];
+    expect(
+      DashboardLabelVariable.getFilter({
+        labelIds: fixed,
+        labelVariableId: saved.id,
+        variables: [saved],
+      }),
+    ).toEqual(new IncludesAnyOfGroups([[NETWORK], [UNIT_660]]));
+    expect(JSON.stringify(saved)).toBe(before);
+    expect(fixed).toEqual([NETWORK, NETWORK]);
+  });
+
+  test("binding survives a variable rename and display name changes", () => {
+    expect(
+      filter({
+        name: "BRANCH",
+        selectedValue: UNIT_660,
+        labelOptions: [{ label: "Renamed unit", value: UNIT_660 }],
+      }),
+    ).toEqual(new Includes([UNIT_660]));
+  });
+
+  test("missing, duplicate, or incompatible variable definitions are errors", () => {
+    for (const variables of [
+      [],
+      [variable(), variable()],
+      [variable({ type: DashboardVariableType.CustomList })],
+    ]) {
+      expect(() => {
+        return DashboardLabelVariable.getFilter({
+          labelVariableId: "unit",
+          variables,
+        });
+      }).toThrow(/label variable/);
+    }
+  });
+
+  test.each(["0660", NETWORK])(
+    "rejects selections not in the configured options: %s",
+    (selectedValue: string) => {
+      expect(() => {
+        return filter({ selectedValue });
+      }).toThrow(/offered by this dashboard/);
+    },
+  );
+
+  test("an invalid default does not silently fall back to all monitors", () => {
+    expect(() => {
+      return filter({ defaultValue: NETWORK });
+    }).toThrow(/offered by this dashboard/);
+  });
+
+  test("validates every multi-selection instead of dropping invalid values", () => {
+    expect(() => {
+      return filter({
+        isMultiSelect: true,
+        selectedValues: [UNIT_660, NETWORK],
+      });
+    }).toThrow(/offered by this dashboard/);
+  });
+
+  test("bounds multi-selection size", () => {
+    expect(() => {
+      return filter({
+        isMultiSelect: true,
+        selectedValues: Array(101).fill(UNIT_660) as Array<string>,
+      });
+    }).toThrow(/100 labels/);
+  });
+
+  test.each([
+    undefined,
+    [],
+    [{ label: "0660", value: "0660" }],
+    [{ label: "", value: UNIT_660 }],
+    [{ label: " ", value: UNIT_660 }],
+    [{ label: "x".repeat(1025), value: UNIT_660 }],
+    [
+      { label: "0660", value: UNIT_660 },
+      { label: "Duplicate", value: UNIT_660 },
+    ],
+    Array(1001).fill({ label: "0660", value: UNIT_660 }),
+  ])(
+    "rejects malformed label choices %#",
+    (labelOptions: DashboardVariable["labelOptions"]) => {
+      expect(() => {
+        return filter({ labelOptions });
+      }).toThrow();
+    },
+  );
+
+  test("filter operators survive the API serialization round trip", () => {
+    const original: IncludesAnyOfGroups = filter({ selectedValue: UNIT_660 }, [
+      NETWORK,
+    ]) as IncludesAnyOfGroups;
+    expect(
+      JSONFunctions.deserializeValue(JSONFunctions.serializeValue(original)),
+    ).toEqual(original);
+  });
+});
+
+describe("dashboard title display interpolation", () => {
+  test.each([
+    [{ selectedValue: UNIT_660 }, "0660 NETWORK"],
+    [{ defaultValue: UNIT_661 }, "0661 NETWORK"],
+    [{ selectedValue: "", defaultValue: UNIT_660 }, "All NETWORK"],
+    [
+      { isMultiSelect: true, selectedValues: [UNIT_660, UNIT_661] },
+      "0660, 0661 NETWORK",
+    ],
+    [
+      { isMultiSelect: true, selectedValues: [], defaultValue: UNIT_660 },
+      "All NETWORK",
+    ],
+    [{ selectedValue: NETWORK }, "Unavailable label NETWORK"],
+  ])(
+    "renders a label selection using display names %#",
+    (overrides: Partial<DashboardVariable>, expected: string) => {
+      expect(
+        DashboardLabelVariable.interpolateTitle("{{UNIT}} NETWORK", [
+          variable(overrides),
+        ]),
+      ).toBe(expected);
+    },
+  );
+
+  test("preserves unknown references and ordinary titles", () => {
+    expect(
+      DashboardLabelVariable.interpolateTitle("{{missing}} NETWORK", [
+        variable(),
+      ]),
+    ).toBe("{{missing}} NETWORK");
+    expect(DashboardLabelVariable.interpolateTitle("Monitors", [])).toBe(
+      "Monitors",
+    );
+    expect(
+      DashboardLabelVariable.interpolateTitle(undefined, []),
+    ).toBeUndefined();
+  });
+
+  test("supports multiple references and text values without interpreting markup", () => {
+    const text: DashboardVariable = {
+      id: "env",
+      name: "ENV",
+      type: DashboardVariableType.TextInput,
+      selectedValue: "<b>prod</b>",
+    };
+    expect(
+      DashboardLabelVariable.interpolateTitle("{{UNIT}} / {{ENV}} / {{UNIT}}", [
+        variable({ selectedValue: UNIT_660 }),
+        text,
+      ]),
+    ).toBe("0660 / <b>prod</b> / 0660");
+  });
+});

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

@@ -100,7 +100,10 @@ describe("DashboardVariableUrlState", () => {
     });
 
     test("applies multi-selected values from the url", () => {
-      const variable: DashboardVariable = makeVariable({ name: "region" });
+      const variable: DashboardVariable = makeVariable({
+        name: "region",
+        isMultiSelect: true,
+      });
       const result: Array<DashboardVariable> =
         DashboardVariableUrlState.applyUrlToVariables([variable], {
           region: { selectedValues: ["a", "b"] },
@@ -108,6 +111,55 @@ describe("DashboardVariableUrlState", () => {
       expect(result[0]?.selectedValues).toEqual(["a", "b"]);
     });
 
+    test("restores one choice into a multi-select and clears a stale scalar", () => {
+      const variable: DashboardVariable = makeVariable({
+        name: "UNIT",
+        type: DashboardVariableType.ProjectLabel,
+        isMultiSelect: true,
+        selectedValue: "old",
+        selectedValues: ["old"],
+      });
+      const result: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables([variable], {
+          UNIT: { selectedValue: "label-0660" },
+        });
+      expect(result[0]?.selectedValues).toEqual(["label-0660"]);
+      expect(result[0]?.selectedValue).toBeUndefined();
+      expect(variable.selectedValues).toEqual(["old"]);
+    });
+
+    test("normalizes an explicit All to an empty multi-select", () => {
+      const result: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables(
+          [
+            makeVariable({
+              name: "UNIT",
+              isMultiSelect: true,
+              selectedValues: ["old"],
+            }),
+          ],
+          { UNIT: { selectedValue: "" } },
+        );
+      expect(result[0]?.selectedValues).toEqual([]);
+      expect(result[0]?.selectedValue).toBeUndefined();
+    });
+
+    test("normalizes a comma-containing scalar using the single-select definition", () => {
+      const result: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables(
+          [
+            makeVariable({
+              name: "text",
+              type: DashboardVariableType.TextInput,
+              selectedValues: ["stale"],
+            }),
+          ],
+          DashboardVariableUrlState.parseFromSearch("?var-text=a,b"),
+        );
+      expect(result[0]?.selectedValue).toBe("a,b");
+      expect(result[0]?.selectedValues).toBeUndefined();
+    });
+
     test("does not mutate the original variable object", () => {
       const variable: DashboardVariable = makeVariable({
         name: "cluster",
@@ -135,7 +187,7 @@ describe("DashboardVariableUrlState", () => {
     test("a shared url reproduces the selection on the variables", () => {
       const variables: Array<DashboardVariable> = [
         makeVariable({ name: "cluster" }),
-        makeVariable({ name: "region" }),
+        makeVariable({ name: "region", isMultiSelect: true }),
       ];
 
       const fromUrl: Record<string, VariableUrlSnapshot> =
@@ -149,14 +201,7 @@ describe("DashboardVariableUrlState", () => {
       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.
-     */
+    // Explicit All must override any selection persisted in the saved config.
     test("a cleared multi-select survives a url round trip as All", () => {
       window.history.replaceState({}, "", "/dashboard");
       DashboardVariableUrlState.writeToBrowserUrl([
@@ -168,7 +213,7 @@ describe("DashboardVariableUrlState", () => {
         }),
       ]);
 
-      expect(window.location.search).toBe("");
+      expect(window.location.search).toBe("?var-region=");
 
       const applied: Array<DashboardVariable> =
         DashboardVariableUrlState.applyUrlToVariables(
@@ -177,18 +222,60 @@ describe("DashboardVariableUrlState", () => {
               name: "region",
               isMultiSelect: true,
               defaultValue: "us",
+              selectedValues: ["eu"],
             }),
           ],
           DashboardVariableUrlState.parseFromSearch(window.location.search),
         );
 
-      expect(applied[0]?.selectedValues).toBeUndefined();
+      expect(applied[0]?.selectedValues).toEqual([]);
       expect(
         DashboardVariableInterpolation.resolveValue(
           applied[0] as DashboardVariable,
         ),
       ).toBeUndefined();
     });
+
+    test("a single project label selection survives a multi-select URL round trip", () => {
+      window.history.replaceState({}, "", "/dashboard");
+      const variable: DashboardVariable = makeVariable({
+        name: "UNIT",
+        type: DashboardVariableType.ProjectLabel,
+        isMultiSelect: true,
+        selectedValues: ["0660"],
+      });
+      DashboardVariableUrlState.writeToBrowserUrl([variable]);
+      expect(window.location.search).toBe("?var-UNIT=0660");
+      const [restored]: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables(
+          [{ ...variable, selectedValues: undefined }],
+          DashboardVariableUrlState.parseFromSearch(window.location.search),
+        );
+      expect(DashboardVariableInterpolation.resolveValue(restored!)).toEqual({
+        multi: ["0660"],
+      });
+    });
+
+    test("explicit All survives a single-select URL round trip despite a stored default", () => {
+      window.history.replaceState({}, "", "/dashboard");
+      const variable: DashboardVariable = makeVariable({
+        name: "UNIT",
+        type: DashboardVariableType.ProjectLabel,
+        defaultValue: "0660",
+        selectedValue: "",
+      });
+      DashboardVariableUrlState.writeToBrowserUrl([variable]);
+      expect(window.location.search).toBe("?var-UNIT=");
+      const [restored]: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables(
+          [{ ...variable, selectedValue: undefined }],
+          DashboardVariableUrlState.parseFromSearch(window.location.search),
+        );
+      expect(restored?.selectedValue).toBe("");
+      expect(
+        DashboardVariableInterpolation.resolveValue(restored!),
+      ).toBeUndefined();
+    });
   });
 
   describe("writeToBrowserUrl", () => {
@@ -209,7 +296,11 @@ describe("DashboardVariableUrlState", () => {
 
     test("writes multi-selected values joined by commas", () => {
       DashboardVariableUrlState.writeToBrowserUrl([
-        makeVariable({ name: "region", selectedValues: ["us", "eu"] }),
+        makeVariable({
+          name: "region",
+          isMultiSelect: true,
+          selectedValues: ["us", "eu"],
+        }),
       ]);
       expect(
         DashboardVariableUrlState.parseFromSearch(window.location.search)[
@@ -239,6 +330,41 @@ describe("DashboardVariableUrlState", () => {
       expect(window.location.search).toBe("");
     });
 
+    test("keeps explicit All distinct from an untouched default", () => {
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({
+          name: "cleared",
+          selectedValue: "",
+          defaultValue: "prod",
+        }),
+        makeVariable({ name: "untouched", defaultValue: "prod" }),
+        makeVariable({
+          name: "clearedMulti",
+          isMultiSelect: true,
+          selectedValues: [],
+        }),
+        makeVariable({ name: "untouchedMulti", isMultiSelect: true }),
+      ]);
+      expect(window.location.search).toBe("?var-cleared=&var-clearedMulti=");
+    });
+
+    test("writes only the selection field used by the saved selection mode", () => {
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({
+          name: "single",
+          selectedValue: "prod",
+          selectedValues: ["stale"],
+        }),
+        makeVariable({
+          name: "multi",
+          isMultiSelect: true,
+          selectedValue: "stale",
+          selectedValues: [],
+        }),
+      ]);
+      expect(window.location.search).toBe("?var-single=prod&var-multi=");
+    });
+
     test("does not push a new history entry (uses replaceState)", () => {
       const lengthBefore: number = window.history.length;
       DashboardVariableUrlState.writeToBrowserUrl([
@@ -250,7 +376,11 @@ describe("DashboardVariableUrlState", () => {
     test("write -> parse round trip preserves the selection", () => {
       DashboardVariableUrlState.writeToBrowserUrl([
         makeVariable({ name: "cluster", selectedValue: "prod" }),
-        makeVariable({ name: "region", selectedValues: ["us", "eu"] }),
+        makeVariable({
+          name: "region",
+          isMultiSelect: true,
+          selectedValues: ["us", "eu"],
+        }),
       ]);
       const parsed: Record<string, VariableUrlSnapshot> =
         DashboardVariableUrlState.parseFromSearch(window.location.search);

package/Tests/Utils/MetricUnitUtil.test.ts

@@ -235,6 +235,87 @@ describe("MetricUnitUtil", () => {
     });
   });
 
+  describe("getFamilyBaseUnit", () => {
+    test("returns the family's canonical base for every member", () => {
+      for (const unit of [
+        "B",
+        "b",
+        "By",
+        "bytes",
+        "KB",
+        "kby",
+        "MB",
+        "GB",
+        "TB",
+        "PB",
+      ]) {
+        expect(MetricUnitUtil.getFamilyBaseUnit(unit)).toBe("B");
+      }
+
+      for (const unit of [
+        "ns",
+        "µs",
+        "us",
+        "ms",
+        "s",
+        "sec",
+        "seconds",
+        "min",
+        "hours",
+        "d",
+        "days",
+      ]) {
+        expect(MetricUnitUtil.getFamilyBaseUnit(unit)).toBe("sec");
+      }
+
+      for (const unit of ["%", "percent", "1"]) {
+        expect(MetricUnitUtil.getFamilyBaseUnit(unit)).toBe("%");
+      }
+
+      for (const unit of ["bit", "bits", "kbit", "mbit", "gbit"]) {
+        expect(MetricUnitUtil.getFamilyBaseUnit(unit)).toBe("bit");
+      }
+    });
+
+    test("is case- and whitespace-insensitive", () => {
+      expect(MetricUnitUtil.getFamilyBaseUnit("  GB  ")).toBe("B");
+      expect(MetricUnitUtil.getFamilyBaseUnit("MS")).toBe("sec");
+    });
+
+    test("returns null for an unknown or empty unit", () => {
+      expect(MetricUnitUtil.getFamilyBaseUnit(undefined)).toBeNull();
+      expect(MetricUnitUtil.getFamilyBaseUnit("")).toBeNull();
+      expect(MetricUnitUtil.getFamilyBaseUnit("   ")).toBeNull();
+      expect(MetricUnitUtil.getFamilyBaseUnit("cores")).toBeNull();
+      expect(MetricUnitUtil.getFamilyBaseUnit("widgets")).toBeNull();
+      // Binary prefixes are deliberately not in any family here.
+      expect(MetricUnitUtil.getFamilyBaseUnit("KiBy")).toBeNull();
+    });
+
+    /*
+     * The base is the unit every other member converts into with the
+     * family's own converter — this is the contract MetricValueFormatter
+     * relies on when it restates "2500 GB" as bytes before scaling.
+     */
+    test("the base it names round-trips through convertToMetricUnit", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 2500,
+          fromUnit: "GB",
+          metricUnit: MetricUnitUtil.getFamilyBaseUnit("GB") as string,
+        }),
+      ).toBe(2.5e12);
+
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 36,
+          fromUnit: "hours",
+          metricUnit: MetricUnitUtil.getFamilyBaseUnit("hours") as string,
+        }),
+      ).toBe(129600);
+    });
+  });
+
   describe("hasCompatibleUnitFamily", () => {
     test("true for known families", () => {
       expect(MetricUnitUtil.hasCompatibleUnitFamily("bytes")).toBe(true);