@oneuptime/common 11.6.1 → 11.7.0

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/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);
+    });
+  });
+});

package/Tests/Utils/IpCanonicalUtil.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from "@jest/globals";
+import IpCanonicalUtil from "../../Utils/IpCanonicalUtil";
+
+/*
+ * Trap/syslog correlation compares datagram source addresses (Node's
+ * normalized lowercase-compressed form) against user-typed device
+ * hostnames. These pin the RFC 5952 canonicalization that makes every
+ * spelling of the same IPv6 address compare equal — without it, an
+ * IPv6-registered device silently never matches its own traps.
+ */
+
+describe("IpCanonicalUtil.canonicalize", () => {
+  test("IPv4 passes through", () => {
+    expect(IpCanonicalUtil.canonicalize("192.168.1.10")).toBe("192.168.1.10");
+    expect(IpCanonicalUtil.canonicalize("  10.0.0.1  ")).toBe("10.0.0.1");
+  });
+
+  test("non-IP input is returned unchanged", () => {
+    expect(IpCanonicalUtil.canonicalize("switch-01.example.com")).toBe(
+      "switch-01.example.com",
+    );
+    expect(IpCanonicalUtil.canonicalize("")).toBe("");
+  });
+
+  test("uppercase IPv6 lowers", () => {
+    expect(IpCanonicalUtil.canonicalize("2001:DB8::1")).toBe("2001:db8::1");
+  });
+
+  test("fully expanded IPv6 compresses per RFC 5952", () => {
+    expect(IpCanonicalUtil.canonicalize("2001:db8:0:0:0:0:0:1")).toBe(
+      "2001:db8::1",
+    );
+  });
+
+  test("leading zeros are stripped", () => {
+    expect(IpCanonicalUtil.canonicalize("2001:0db8::0001")).toBe("2001:db8::1");
+  });
+
+  test("longest zero run wins; leftmost on ties", () => {
+    expect(IpCanonicalUtil.canonicalize("2001:0:0:1:0:0:0:1")).toBe(
+      "2001:0:0:1::1",
+    );
+    expect(IpCanonicalUtil.canonicalize("2001:db8:0:0:1:0:0:1")).toBe(
+      "2001:db8::1:0:0:1",
+    );
+  });
+
+  test("a single zero group is not compressed", () => {
+    expect(IpCanonicalUtil.canonicalize("2001:db8:0:1:1:1:1:1")).toBe(
+      "2001:db8:0:1:1:1:1:1",
+    );
+  });
+
+  test("all-zeros and loopback", () => {
+    expect(IpCanonicalUtil.canonicalize("0:0:0:0:0:0:0:0")).toBe("::");
+    expect(IpCanonicalUtil.canonicalize("0:0:0:0:0:0:0:1")).toBe("::1");
+    expect(IpCanonicalUtil.canonicalize("::1")).toBe("::1");
+  });
+
+  test("IPv4-mapped tails fold into hex groups", () => {
+    expect(IpCanonicalUtil.canonicalize("::ffff:192.168.1.1")).toBe(
+      IpCanonicalUtil.canonicalize("::ffff:c0a8:101"),
+    );
+  });
+});
+
+describe("IpCanonicalUtil.areSameIpAddress", () => {
+  test("matches different spellings of one IPv6 address", () => {
+    expect(
+      IpCanonicalUtil.areSameIpAddress("2001:DB8::1", "2001:db8:0:0:0:0:0:1"),
+    ).toBe(true);
+  });
+
+  test("distinct addresses do not match", () => {
+    expect(IpCanonicalUtil.areSameIpAddress("2001:db8::1", "2001:db8::2")).toBe(
+      false,
+    );
+  });
+
+  test("DNS names never match as IPs", () => {
+    expect(
+      IpCanonicalUtil.areSameIpAddress("switch.example.com", "2001:db8::1"),
+    ).toBe(false);
+  });
+});

package/Tests/Utils/Memory.test.ts

@@ -0,0 +1,44 @@
+import MemoryUtil from "../../Utils/Memory";
+
+/*
+ * MemoryUtil.convertToGb turns a raw byte count into gibibytes (bytes / 1024^3)
+ * rounded to two decimal places. These tests pin the unit (GiB, not GB), the
+ * rounding, and the boundary/edge behaviour.
+ */
+describe("MemoryUtil.convertToGb", () => {
+  const GIB: number = 1024 * 1024 * 1024;
+
+  test("converts exactly one GiB to 1", () => {
+    expect(MemoryUtil.convertToGb(GIB)).toBe(1);
+  });
+
+  test("converts whole GiB multiples", () => {
+    expect(MemoryUtil.convertToGb(4 * GIB)).toBe(4);
+    expect(MemoryUtil.convertToGb(16 * GIB)).toBe(16);
+  });
+
+  test("returns 0 for 0 bytes", () => {
+    expect(MemoryUtil.convertToGb(0)).toBe(0);
+  });
+
+  test("rounds to two decimal places", () => {
+    // 1.5 GiB -> 1.5
+    expect(MemoryUtil.convertToGb(1.5 * GIB)).toBe(1.5);
+    // 1.234 GiB rounds to 1.23
+    expect(MemoryUtil.convertToGb(1.234 * GIB)).toBe(1.23);
+    // 1.235 GiB rounds up to 1.24 (round-half-up)
+    expect(MemoryUtil.convertToGb(1.235 * GIB)).toBe(1.24);
+  });
+
+  test("handles sub-GiB values", () => {
+    // 512 MiB is half a GiB.
+    expect(MemoryUtil.convertToGb(512 * 1024 * 1024)).toBe(0.5);
+    // A single byte rounds down to 0.
+    expect(MemoryUtil.convertToGb(1)).toBe(0);
+  });
+
+  test("uses GiB (1024^3), not GB (1000^3)", () => {
+    // One billion bytes is < 1 GiB, so it must not round to 1.
+    expect(MemoryUtil.convertToGb(1_000_000_000)).toBe(0.93);
+  });
+});