@oneuptime/common 11.6.0 → 11.6.2

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

@@ -0,0 +1,259 @@
+import {
+  ComponentArgument,
+  ComponentInputType,
+  EntityFilterModelType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardBaseComponent from "../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import DashboardSloComponent, {
+  SloWidgetDisplayType,
+  SloWidgetMetric,
+} from "../../../Types/Dashboard/DashboardComponents/DashboardSloComponent";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import { ObjectType } from "../../../Types/JSON";
+import DashboardComponentsUtil from "../../../Utils/Dashboard/Components/Index";
+import DashboardSloComponentUtil from "../../../Utils/Dashboard/Components/DashboardSloComponent";
+
+type ArgumentIds = keyof DashboardSloComponent["arguments"];
+
+function getArguments(): Array<ComponentArgument<DashboardSloComponent>> {
+  return DashboardSloComponentUtil.getComponentConfigArguments();
+}
+
+function getArgumentById(
+  id: ArgumentIds,
+): ComponentArgument<DashboardSloComponent> {
+  const found: ComponentArgument<DashboardSloComponent> | undefined =
+    getArguments().find((arg: ComponentArgument<DashboardSloComponent>) => {
+      return arg.id === id;
+    });
+
+  if (!found) {
+    throw new Error(`No SLO widget argument declared with id "${id}"`);
+  }
+
+  return found;
+}
+
+describe("DashboardSloComponentUtil", () => {
+  describe("getDefaultComponent", () => {
+    it("declares its componentType as Slo so the renderer dispatch matches", () => {
+      expect(
+        DashboardSloComponentUtil.getDefaultComponent().componentType,
+      ).toBe(DashboardComponentType.Slo);
+    });
+
+    it("marks itself as a dashboard component so it survives config serialization", () => {
+      expect(DashboardSloComponentUtil.getDefaultComponent()._type).toBe(
+        ObjectType.DashboardComponent,
+      );
+    });
+
+    it("defaults to a 3x3 tile placed at the canvas origin", () => {
+      const component: DashboardSloComponent =
+        DashboardSloComponentUtil.getDefaultComponent();
+
+      expect(component.widthInDashboardUnits).toBe(3);
+      expect(component.heightInDashboardUnits).toBe(3);
+      expect(component.topInDashboardUnits).toBe(0);
+      expect(component.leftInDashboardUnits).toBe(0);
+    });
+
+    it("cannot be resized smaller than its 2x2 minimum", () => {
+      const component: DashboardSloComponent =
+        DashboardSloComponentUtil.getDefaultComponent();
+
+      expect(component.minWidthInDashboardUnits).toBe(2);
+      expect(component.minHeightInDashboardUnits).toBe(2);
+      expect(component.minWidthInDashboardUnits).toBeLessThanOrEqual(
+        component.widthInDashboardUnits,
+      );
+      expect(component.minHeightInDashboardUnits).toBeLessThanOrEqual(
+        component.heightInDashboardUnits,
+      );
+    });
+
+    it("defaults the metric to SLI and the display to Tile", () => {
+      const component: DashboardSloComponent =
+        DashboardSloComponentUtil.getDefaultComponent();
+
+      expect(component.arguments.sloMetric).toBe(SloWidgetMetric.Sli);
+      expect(component.arguments.displayType).toBe(SloWidgetDisplayType.Tile);
+    });
+
+    it("leaves the SLO unselected so the widget renders its setup state", () => {
+      const component: DashboardSloComponent =
+        DashboardSloComponentUtil.getDefaultComponent();
+
+      expect(component.arguments.serviceLevelObjectiveId).toBeUndefined();
+      expect(component.arguments.widgetTitle).toBeUndefined();
+    });
+
+    it("generates a distinct componentId per call so two widgets never collide", () => {
+      const first: DashboardSloComponent =
+        DashboardSloComponentUtil.getDefaultComponent();
+      const second: DashboardSloComponent =
+        DashboardSloComponentUtil.getDefaultComponent();
+
+      expect(first.componentId.toString()).not.toBe(
+        second.componentId.toString(),
+      );
+    });
+  });
+
+  describe("getComponentConfigArguments", () => {
+    it("declares exactly the four documented arguments", () => {
+      expect(
+        getArguments().map((arg: ComponentArgument<DashboardSloComponent>) => {
+          return arg.id;
+        }),
+      ).toEqual([
+        "serviceLevelObjectiveId",
+        "sloMetric",
+        "displayType",
+        "widgetTitle",
+      ]);
+    });
+
+    it("gives every argument a name, description, input type and required flag", () => {
+      for (const arg of getArguments()) {
+        expect(typeof arg.name).toBe("string");
+        expect(arg.name.length).toBeGreaterThan(0);
+        expect(typeof arg.description).toBe("string");
+        expect(arg.description.length).toBeGreaterThan(0);
+        expect(Object.values(ComponentInputType)).toContain(arg.type);
+        expect(typeof arg.required).toBe("boolean");
+      }
+    });
+
+    it("puts every argument in a section so the settings panel can group them", () => {
+      for (const arg of getArguments()) {
+        expect(arg.section).toBeDefined();
+        expect(arg.section?.name.length).toBeGreaterThan(0);
+        expect(typeof arg.section?.order).toBe("number");
+      }
+    });
+
+    it("picks the SLO with a model-backed entity dropdown", () => {
+      const arg: ComponentArgument<DashboardSloComponent> = getArgumentById(
+        "serviceLevelObjectiveId",
+      );
+
+      expect(arg.type).toBe(ComponentInputType.EntityDropdown);
+      expect(arg.entityFilterModelType).toBe(
+        EntityFilterModelType.ServiceLevelObjective,
+      );
+      expect(arg.required).toBe(true);
+    });
+
+    it("offers all three SLO metrics in the metric dropdown", () => {
+      const arg: ComponentArgument<DashboardSloComponent> =
+        getArgumentById("sloMetric");
+
+      expect(arg.type).toBe(ComponentInputType.Dropdown);
+      expect(
+        arg.dropdownOptions?.map((option: { value: unknown }) => {
+          return option.value;
+        }),
+      ).toEqual([
+        SloWidgetMetric.Sli,
+        SloWidgetMetric.ErrorBudgetRemaining,
+        SloWidgetMetric.BurnRate,
+      ]);
+    });
+
+    it("offers both display types in the display dropdown", () => {
+      const arg: ComponentArgument<DashboardSloComponent> =
+        getArgumentById("displayType");
+
+      expect(arg.type).toBe(ComponentInputType.Dropdown);
+      expect(
+        arg.dropdownOptions?.map((option: { value: unknown }) => {
+          return option.value;
+        }),
+      ).toEqual([SloWidgetDisplayType.Tile, SloWidgetDisplayType.Chart]);
+    });
+
+    it("keeps the title optional because it falls back to the SLO name", () => {
+      const arg: ComponentArgument<DashboardSloComponent> =
+        getArgumentById("widgetTitle");
+
+      expect(arg.type).toBe(ComponentInputType.Text);
+      expect(arg.required).toBe(false);
+    });
+
+    it("gives every dropdown argument a non-empty option list", () => {
+      const dropdownArgs: Array<ComponentArgument<DashboardSloComponent>> =
+        getArguments().filter(
+          (arg: ComponentArgument<DashboardSloComponent>) => {
+            return arg.type === ComponentInputType.Dropdown;
+          },
+        );
+
+      expect(dropdownArgs.length).toBeGreaterThan(0);
+
+      for (const arg of dropdownArgs) {
+        expect(arg.dropdownOptions?.length).toBeGreaterThan(0);
+
+        for (const option of arg.dropdownOptions || []) {
+          expect(typeof option.label).toBe("string");
+          expect((option.label as string).length).toBeGreaterThan(0);
+          expect(option.value).toBeTruthy();
+        }
+      }
+    });
+
+    it("declares no duplicate argument ids", () => {
+      const ids: Array<unknown> = getArguments().map(
+        (arg: ComponentArgument<DashboardSloComponent>) => {
+          return arg.id;
+        },
+      );
+
+      expect(new Set(ids).size).toBe(ids.length);
+    });
+  });
+
+  /*
+   * These go through the registry's public lookup rather than the util
+   * directly, so forgetting to wire DashboardComponentType.Slo into
+   * Common/Utils/Dashboard/Components/Index.ts fails the suite.
+   */
+  describe("registration in DashboardComponentsUtil", () => {
+    it("resolves DashboardComponentType.Slo instead of throwing for an unknown type", () => {
+      expect(() => {
+        return DashboardComponentsUtil.getComponentSettingsArguments(
+          DashboardComponentType.Slo,
+        );
+      }).not.toThrow();
+    });
+
+    it("returns the SLO widget's own arguments for DashboardComponentType.Slo", () => {
+      const fromRegistry: Array<ComponentArgument<DashboardBaseComponent>> =
+        DashboardComponentsUtil.getComponentSettingsArguments(
+          DashboardComponentType.Slo,
+        );
+
+      expect(
+        fromRegistry.map(
+          (arg: ComponentArgument<DashboardBaseComponent>): unknown => {
+            return arg.id;
+          },
+        ),
+      ).toEqual(
+        getArguments().map(
+          (arg: ComponentArgument<DashboardSloComponent>): unknown => {
+            return arg.id;
+          },
+        ),
+      );
+    });
+
+    it("still throws for a component type that is not registered", () => {
+      expect(() => {
+        return DashboardComponentsUtil.getComponentSettingsArguments(
+          "NotARealWidget" as DashboardComponentType,
+        );
+      }).toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,162 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+import DashboardModelQueryInterpolation, {
+  AttributeToColumnMap,
+} from "../../../Utils/Dashboard/ModelQueryVariableInterpolation";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * DashboardModelQueryInterpolation rewrites a Postgres model query so a list
+ * widget honours the dashboard's telemetry-attribute variables — mapping the
+ * OTel attribute key (host.name) to the model column (hostname) and writing
+ * the predicate. Key behaviors under test: it only touches mapped
+ * TelemetryAttribute variables, single vs multi select produce scalar vs
+ * Includes predicates, an empty selection clears a prior filter, and the input
+ * query object is never mutated (a fresh object is returned only on change).
+ */
+
+function attrVariable(
+  attributeKey: string,
+  overrides: Partial<DashboardVariable>,
+): DashboardVariable {
+  return {
+    id: attributeKey,
+    name: attributeKey,
+    type: DashboardVariableType.TelemetryAttribute,
+    attributeKey,
+    ...overrides,
+  };
+}
+
+const MAP: AttributeToColumnMap = {
+  "host.name": "hostname",
+  "k8s.namespace.name": "namespace",
+};
+
+describe("DashboardModelQueryInterpolation.applyToQuery - no-ops", () => {
+  test("returns the same query object when there are no variables", () => {
+    const query: Record<string, unknown> = { foo: "bar" };
+    expect(
+      DashboardModelQueryInterpolation.applyToQuery(query, undefined, MAP),
+    ).toBe(query);
+    expect(DashboardModelQueryInterpolation.applyToQuery(query, [], MAP)).toBe(
+      query,
+    );
+  });
+
+  test("returns the same query object when the attribute map is empty", () => {
+    const query: Record<string, unknown> = { foo: "bar" };
+    const variables: Array<DashboardVariable> = [
+      attrVariable("host.name", { selectedValue: "web1" }),
+    ];
+    expect(
+      DashboardModelQueryInterpolation.applyToQuery(query, variables, {}),
+    ).toBe(query);
+  });
+
+  test("ignores non-TelemetryAttribute variables and unmapped keys", () => {
+    const query: Record<string, unknown> = { foo: "bar" };
+    const variables: Array<DashboardVariable> = [
+      {
+        id: "t",
+        name: "t",
+        type: DashboardVariableType.TextInput,
+        selectedValue: "x",
+      },
+      attrVariable("unmapped.key", { selectedValue: "y" }),
+    ];
+    expect(
+      DashboardModelQueryInterpolation.applyToQuery(query, variables, MAP),
+    ).toBe(query);
+  });
+});
+
+describe("DashboardModelQueryInterpolation.applyToQuery - writing predicates", () => {
+  test("writes a scalar predicate for a single-select variable", () => {
+    const query: Record<string, unknown> = {};
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        query,
+        [attrVariable("host.name", { selectedValue: "web1" })],
+        MAP,
+      );
+
+    expect(result).not.toBe(query); // fresh object
+    expect(query).toEqual({}); // input untouched
+    expect(result["hostname"]).toBe("web1");
+  });
+
+  test("writes an Includes predicate for a multi-select variable", () => {
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        {},
+        [
+          attrVariable("host.name", {
+            isMultiSelect: true,
+            selectedValues: ["web1", "web2"],
+          }),
+        ],
+        MAP,
+      );
+
+    expect(result["hostname"]).toBeInstanceOf(Includes);
+    expect((result["hostname"] as Includes).values).toEqual(["web1", "web2"]);
+  });
+
+  test("maps two variables onto their respective columns", () => {
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        {},
+        [
+          attrVariable("host.name", { selectedValue: "web1" }),
+          attrVariable("k8s.namespace.name", { selectedValue: "prod" }),
+        ],
+        MAP,
+      );
+
+    expect(result["hostname"]).toBe("web1");
+    expect(result["namespace"]).toBe("prod");
+  });
+});
+
+describe("DashboardModelQueryInterpolation.applyToQuery - clearing predicates", () => {
+  test("an empty selection removes a prior filter on that column", () => {
+    const query: Record<string, unknown> = { hostname: "old" };
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        query,
+        [attrVariable("host.name", { selectedValue: "" })],
+        MAP,
+      );
+
+    expect(result).not.toBe(query);
+    expect(result).not.toHaveProperty("hostname");
+    // input query left intact
+    expect(query["hostname"]).toBe("old");
+  });
+
+  test("an empty selection with no prior filter is a no-op (same object)", () => {
+    const query: Record<string, unknown> = { other: "x" };
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        query,
+        [attrVariable("host.name", { selectedValue: "" })],
+        MAP,
+      );
+
+    expect(result).toBe(query);
+  });
+
+  test("falls back to defaultValue when nothing is selected", () => {
+    const result: Record<string, unknown> =
+      DashboardModelQueryInterpolation.applyToQuery(
+        {},
+        [attrVariable("host.name", { defaultValue: "default-host" })],
+        MAP,
+      );
+
+    expect(result["hostname"]).toBe("default-host");
+  });
+});

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

@@ -0,0 +1,197 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+import DashboardVariableInterpolation from "../../../Utils/Dashboard/VariableInterpolation";
+
+function makeVariable(
+  overrides: Partial<DashboardVariable>,
+): DashboardVariable {
+  return {
+    id: "var-1",
+    name: "cluster",
+    type: DashboardVariableType.TelemetryAttribute,
+    ...overrides,
+  } as DashboardVariable;
+}
+
+describe("DashboardVariableInterpolation", () => {
+  describe("resolveValue", () => {
+    test("returns scalar for a single-select with selectedValue", () => {
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "prod",
+      });
+    });
+
+    test("falls back to defaultValue when selectedValue is unset", () => {
+      const variable: DashboardVariable = makeVariable({
+        defaultValue: "staging",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "staging",
+      });
+    });
+
+    test("prefers selectedValue over defaultValue", () => {
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+        defaultValue: "staging",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "prod",
+      });
+    });
+
+    test("returns undefined when nothing is selected", () => {
+      expect(
+        DashboardVariableInterpolation.resolveValue(makeVariable({})),
+      ).toBeUndefined();
+      expect(
+        DashboardVariableInterpolation.resolveValue(
+          makeVariable({ selectedValue: "" }),
+        ),
+      ).toBeUndefined();
+    });
+
+    test("returns multi for a multi-select with values", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: ["a", "b"],
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        multi: ["a", "b"],
+      });
+    });
+
+    test("filters out empty values in multi-select", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: ["a", "", "b"],
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        multi: ["a", "b"],
+      });
+    });
+
+    test("multi-select with no picks falls through to scalar default", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: [],
+        defaultValue: "d",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "d",
+      });
+    });
+  });
+
+  describe("applyToAttributes", () => {
+    test("returns the same reference when there are no variables", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, undefined),
+      ).toBe(attrs);
+      expect(DashboardVariableInterpolation.applyToAttributes(attrs, [])).toBe(
+        attrs,
+      );
+    });
+
+    test("injects a scalar attribute for a selected variable", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [variable]);
+      expect(result).toEqual({ "k8s.cluster.name": "prod" });
+    });
+
+    test("emits an Includes operator for multi-select", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        isMultiSelect: true,
+        selectedValues: ["a", "b"],
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [variable]);
+      const value: unknown = result["k8s.cluster.name"];
+      expect(value).toBeInstanceOf(Includes);
+      expect((value as Includes).values).toEqual(["a", "b"]);
+    });
+
+    test("removes a previously-set filter when selection is cleared (All)", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(
+          { "k8s.cluster.name": "prod", other: "keep" },
+          [variable],
+        );
+      expect(result).toEqual({ other: "keep" });
+    });
+
+    test("ignores non-TelemetryAttribute variables", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      const variable: DashboardVariable = makeVariable({
+        type: DashboardVariableType.TextInput,
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("ignores TelemetryAttribute variables without an attributeKey", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("returns same reference when scalar value is already set", () => {
+      const attrs: Record<string, unknown> = { "k8s.cluster.name": "prod" };
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("handles undefined attributes map", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(undefined, [variable]);
+      expect(result).toEqual({ "k8s.cluster.name": "prod" });
+    });
+
+    test("applies multiple variables at once", () => {
+      const v1: DashboardVariable = makeVariable({
+        id: "v1",
+        attributeKey: "cluster",
+        selectedValue: "prod",
+      });
+      const v2: DashboardVariable = makeVariable({
+        id: "v2",
+        attributeKey: "namespace",
+        selectedValue: "default",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [v1, v2]);
+      expect(result).toEqual({ cluster: "prod", namespace: "default" });
+    });
+  });
+});

package/Tests/Utils/Enum.test.ts

@@ -0,0 +1,54 @@
+import EnumUtil from "../../Utils/Enum";
+
+enum StringEnum {
+  First = "First",
+  Second = "second-value",
+}
+
+enum NumericEnum {
+  Zero,
+  One,
+}
+
+describe("EnumUtil", () => {
+  describe("getValues", () => {
+    test("should return the values of a string enum", () => {
+      expect(EnumUtil.getValues(StringEnum)).toEqual(["First", "second-value"]);
+    });
+
+    test("should return an empty array for an empty object", () => {
+      expect(EnumUtil.getValues({})).toEqual([]);
+    });
+
+    test("should include reverse mapped keys for numeric enums", () => {
+      /*
+       * TypeScript numeric enums are bidirectional, so Object.values() contains
+       * both the names and the numbers.
+       */
+      const values: Array<string> = EnumUtil.getValues(NumericEnum);
+
+      expect(values).toContain("Zero");
+      expect(values).toContain("One");
+      expect(values).toContain(0 as unknown as string);
+      expect(values).toContain(1 as unknown as string);
+    });
+  });
+
+  describe("isValidEnumValue", () => {
+    test("should return true for a value in the enum", () => {
+      expect(EnumUtil.isValidEnumValue(StringEnum, "First")).toBe(true);
+      expect(EnumUtil.isValidEnumValue(StringEnum, "second-value")).toBe(true);
+    });
+
+    test("should return false for the enum key when it differs from the value", () => {
+      expect(EnumUtil.isValidEnumValue(StringEnum, "Second")).toBe(false);
+    });
+
+    test("should return false for values not in the enum", () => {
+      expect(EnumUtil.isValidEnumValue(StringEnum, "Third")).toBe(false);
+      expect(EnumUtil.isValidEnumValue(StringEnum, null)).toBe(false);
+      expect(EnumUtil.isValidEnumValue(StringEnum, undefined)).toBe(false);
+      expect(EnumUtil.isValidEnumValue(StringEnum, 0)).toBe(false);
+    });
+  });
+});