@oneuptime/common 10.0.65 → 10.0.66

package/Tests/Utils/MetricUnitUtil.test.ts

@@ -0,0 +1,216 @@
+import MetricUnitUtil from "../../Utils/MetricUnitUtil";
+
+describe("MetricUnitUtil", () => {
+  describe("getCompatibleUnits", () => {
+    test("returns empty array for undefined / empty unit", () => {
+      expect(MetricUnitUtil.getCompatibleUnits(undefined)).toEqual([]);
+      expect(MetricUnitUtil.getCompatibleUnits("")).toEqual([]);
+      expect(MetricUnitUtil.getCompatibleUnits("   ")).toEqual([]);
+    });
+
+    test("returns byte family for 'bytes'", () => {
+      const options: Array<{ value: string; label: string }> =
+        MetricUnitUtil.getCompatibleUnits("bytes");
+      const values: Array<string> = options.map(
+        (o: { value: string; label: string }) => {
+          return o.value;
+        },
+      );
+      expect(values).toEqual(["B", "KB", "MB", "GB", "TB", "PB"]);
+    });
+
+    test("returns byte family for UCUM 'By' code", () => {
+      const options: Array<{ value: string; label: string }> =
+        MetricUnitUtil.getCompatibleUnits("By");
+      expect(options.length).toBe(6);
+      expect(options[0]!.value).toBe("B");
+    });
+
+    test("returns time family for 'ms'", () => {
+      const values: Array<string> = MetricUnitUtil.getCompatibleUnits("ms").map(
+        (o: { value: string; label: string }) => {
+          return o.value;
+        },
+      );
+      expect(values).toEqual(["ns", "µs", "ms", "sec", "min", "hours", "days"]);
+    });
+
+    test("returns time family for 's'", () => {
+      const values: Array<string> = MetricUnitUtil.getCompatibleUnits("s").map(
+        (o: { value: string; label: string }) => {
+          return o.value;
+        },
+      );
+      expect(values).toContain("sec");
+      expect(values).toContain("ms");
+      expect(values).toContain("hours");
+    });
+
+    test("returns percent family for '%'", () => {
+      const options: Array<{ value: string; label: string }> =
+        MetricUnitUtil.getCompatibleUnits("%");
+      expect(options).toEqual([{ value: "%", label: "Percent (%)" }]);
+    });
+
+    test("returns raw unit as sole option for unknown unit", () => {
+      const options: Array<{ value: string; label: string }> =
+        MetricUnitUtil.getCompatibleUnits("widgets");
+      expect(options).toEqual([{ value: "widgets", label: "widgets" }]);
+    });
+  });
+
+  describe("getCanonicalUnitValue", () => {
+    test("returns canonical value for aliases", () => {
+      expect(MetricUnitUtil.getCanonicalUnitValue("bytes")).toBe("B");
+      expect(MetricUnitUtil.getCanonicalUnitValue("Byte")).toBe("B");
+      expect(MetricUnitUtil.getCanonicalUnitValue("MB")).toBe("MB");
+      expect(MetricUnitUtil.getCanonicalUnitValue("milliseconds")).toBe("ms");
+      expect(MetricUnitUtil.getCanonicalUnitValue("second")).toBe("sec");
+      expect(MetricUnitUtil.getCanonicalUnitValue("percent")).toBe("%");
+    });
+
+    test("passes through unknown units", () => {
+      expect(MetricUnitUtil.getCanonicalUnitValue("widgets")).toBe("widgets");
+    });
+
+    test("returns undefined for empty", () => {
+      expect(MetricUnitUtil.getCanonicalUnitValue(undefined)).toBeUndefined();
+      expect(MetricUnitUtil.getCanonicalUnitValue("")).toBeUndefined();
+    });
+  });
+
+  describe("convertToMetricUnit", () => {
+    test("no conversion when units match", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 123,
+          fromUnit: "MB",
+          metricUnit: "MB",
+        }),
+      ).toBe(123);
+    });
+
+    test("converts MB to bytes", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 2,
+          fromUnit: "MB",
+          metricUnit: "bytes",
+        }),
+      ).toBe(2e6);
+    });
+
+    test("converts bytes to GB", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 5e9,
+          fromUnit: "bytes",
+          metricUnit: "GB",
+        }),
+      ).toBe(5);
+    });
+
+    test("converts sec to ms", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 2,
+          fromUnit: "sec",
+          metricUnit: "ms",
+        }),
+      ).toBe(2000);
+    });
+
+    test("converts ms to sec", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 1500,
+          fromUnit: "ms",
+          metricUnit: "sec",
+        }),
+      ).toBe(1.5);
+    });
+
+    test("converts min to sec", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 2,
+          fromUnit: "min",
+          metricUnit: "sec",
+        }),
+      ).toBe(120);
+    });
+
+    test("converts hours to ms", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 1,
+          fromUnit: "hours",
+          metricUnit: "ms",
+        }),
+      ).toBe(3_600_000);
+    });
+
+    test("returns value unchanged when units are from different families", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 100,
+          fromUnit: "MB",
+          metricUnit: "sec",
+        }),
+      ).toBe(100);
+    });
+
+    test("returns value unchanged when metric unit is unknown", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 100,
+          fromUnit: "MB",
+          metricUnit: "widgets",
+        }),
+      ).toBe(100);
+    });
+
+    test("returns value unchanged when either unit is missing", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 100,
+          fromUnit: undefined,
+          metricUnit: "bytes",
+        }),
+      ).toBe(100);
+
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 100,
+          fromUnit: "MB",
+          metricUnit: undefined,
+        }),
+      ).toBe(100);
+    });
+
+    test("handles case-insensitive unit matching", () => {
+      expect(
+        MetricUnitUtil.convertToMetricUnit({
+          value: 2,
+          fromUnit: "gb",
+          metricUnit: "BYTES",
+        }),
+      ).toBe(2e9);
+    });
+  });
+
+  describe("hasCompatibleUnitFamily", () => {
+    test("true for known families", () => {
+      expect(MetricUnitUtil.hasCompatibleUnitFamily("bytes")).toBe(true);
+      expect(MetricUnitUtil.hasCompatibleUnitFamily("ms")).toBe(true);
+      expect(MetricUnitUtil.hasCompatibleUnitFamily("%")).toBe(true);
+      expect(MetricUnitUtil.hasCompatibleUnitFamily("GB")).toBe(true);
+    });
+
+    test("false for unknown or empty", () => {
+      expect(MetricUnitUtil.hasCompatibleUnitFamily(undefined)).toBe(false);
+      expect(MetricUnitUtil.hasCompatibleUnitFamily("")).toBe(false);
+      expect(MetricUnitUtil.hasCompatibleUnitFamily("widgets")).toBe(false);
+    });
+  });
+});

package/Tests/Utils/Metrics/MetricFormulaEvaluator.test.ts

@@ -0,0 +1,269 @@
+import MetricFormulaEvaluator from "../../../Utils/Metrics/MetricFormulaEvaluator";
+import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+
+type BuildQueryConfigFunction = (variable: string) => MetricQueryConfigData;
+
+const buildQueryConfig: BuildQueryConfigFunction = (
+  variable: string,
+): MetricQueryConfigData => {
+  return {
+    metricAliasData: {
+      metricVariable: variable,
+      title: "",
+      description: "",
+      legend: "",
+      legendUnit: "",
+    },
+    metricQueryData: {
+      filterData: {
+        metricName: `metric_${variable}`,
+        aggegationType: MetricsAggregationType.Avg,
+      },
+    },
+  };
+};
+
+type BuildResultFunction = (
+  points: Array<{ timestamp: string; value: number }>,
+) => AggregatedResult;
+
+const buildResult: BuildResultFunction = (
+  points: Array<{ timestamp: string; value: number }>,
+): AggregatedResult => {
+  return {
+    data: points.map((point: { timestamp: string; value: number }) => {
+      return {
+        timestamp: new Date(point.timestamp),
+        value: point.value,
+      };
+    }),
+  };
+};
+
+describe("MetricFormulaEvaluator", () => {
+  describe("evaluateFormula", () => {
+    test("adds two series point-by-point", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildQueryConfig("a"),
+        buildQueryConfig("b"),
+      ];
+      const results: Array<AggregatedResult> = [
+        buildResult([
+          { timestamp: "2024-01-01T00:00:00.000Z", value: 10 },
+          { timestamp: "2024-01-01T00:01:00.000Z", value: 20 },
+        ]),
+        buildResult([
+          { timestamp: "2024-01-01T00:00:00.000Z", value: 1 },
+          { timestamp: "2024-01-01T00:01:00.000Z", value: 2 },
+        ]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a + b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(
+        output.data.map((p: { value: number }) => {
+          return p.value;
+        }),
+      ).toEqual([11, 22]);
+    });
+
+    test("supports $ prefix, numeric literals and precedence", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildQueryConfig("a"),
+        buildQueryConfig("b"),
+      ];
+      const results: Array<AggregatedResult> = [
+        buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 3 }]),
+        buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 4 }]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "($A + $B) * 2",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(output.data[0]!.value).toBe(14);
+    });
+
+    test("handles unary minus and division", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildQueryConfig("a"),
+      ];
+      const results: Array<AggregatedResult> = [
+        buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 100 }]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "-a / 2",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(output.data[0]!.value).toBe(-50);
+    });
+
+    test("skips timestamps where any variable is missing", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildQueryConfig("a"),
+        buildQueryConfig("b"),
+      ];
+      const results: Array<AggregatedResult> = [
+        buildResult([
+          { timestamp: "2024-01-01T00:00:00.000Z", value: 10 },
+          { timestamp: "2024-01-01T00:01:00.000Z", value: 20 },
+        ]),
+        buildResult([
+          // "b" missing the first timestamp
+          { timestamp: "2024-01-01T00:01:00.000Z", value: 5 },
+        ]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a - b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(output.data.length).toBe(1);
+      expect(output.data[0]!.value).toBe(15);
+    });
+
+    test("drops non-finite results like divide-by-zero", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildQueryConfig("a"),
+        buildQueryConfig("b"),
+      ];
+      const results: Array<AggregatedResult> = [
+        buildResult([
+          { timestamp: "2024-01-01T00:00:00.000Z", value: 10 },
+          { timestamp: "2024-01-01T00:01:00.000Z", value: 10 },
+        ]),
+        buildResult([
+          { timestamp: "2024-01-01T00:00:00.000Z", value: 0 },
+          { timestamp: "2024-01-01T00:01:00.000Z", value: 2 },
+        ]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a / b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(output.data.length).toBe(1);
+      expect(output.data[0]!.value).toBe(5);
+    });
+
+    test("references another formula's pre-computed result", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildQueryConfig("a"),
+        buildQueryConfig("b"),
+      ];
+
+      const formulaC: MetricFormulaConfigData = {
+        metricAliasData: {
+          metricVariable: "c",
+          title: "",
+          description: "",
+          legend: "",
+          legendUnit: "",
+        },
+        metricFormulaData: {
+          metricFormula: "a + b",
+        },
+      };
+
+      const rawResults: Array<AggregatedResult> = [
+        buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 4 }]),
+        buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 6 }]),
+      ];
+
+      const resultC: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: formulaC.metricFormulaData.metricFormula,
+        queryConfigs,
+        formulaConfigs: [],
+        results: rawResults,
+      });
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "c * 10",
+        queryConfigs,
+        formulaConfigs: [formulaC],
+        results: [...rawResults, resultC],
+      });
+
+      expect(output.data[0]!.value).toBe(100);
+    });
+
+    test("returns empty data for an empty formula", () => {
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "   ",
+        queryConfigs: [buildQueryConfig("a")],
+        formulaConfigs: [],
+        results: [buildResult([])],
+      });
+      expect(output.data).toEqual([]);
+    });
+
+    test("throws for unknown variables", () => {
+      expect(() => {
+        MetricFormulaEvaluator.evaluateFormula({
+          formula: "a + z",
+          queryConfigs: [buildQueryConfig("a")],
+          formulaConfigs: [],
+          results: [
+            buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 1 }]),
+          ],
+        });
+      }).toThrow(/unknown variable/i);
+    });
+  });
+
+  describe("validateFormula", () => {
+    test("returns null for a valid formula", () => {
+      expect(
+        MetricFormulaEvaluator.validateFormula({
+          formula: "(a + b) * 2",
+          availableVariables: ["a", "b"],
+        }),
+      ).toBeNull();
+    });
+
+    test("reports missing variable", () => {
+      const message: string | null = MetricFormulaEvaluator.validateFormula({
+        formula: "a + c",
+        availableVariables: ["a", "b"],
+      });
+      expect(message).toMatch(/unknown variable/i);
+    });
+
+    test("reports syntax errors", () => {
+      const message: string | null = MetricFormulaEvaluator.validateFormula({
+        formula: "(a + b",
+        availableVariables: ["a", "b"],
+      });
+      expect(message).toMatch(/parentheses/i);
+    });
+
+    test("rejects empty formulas", () => {
+      const message: string | null = MetricFormulaEvaluator.validateFormula({
+        formula: "",
+        availableVariables: ["a"],
+      });
+      expect(message).toMatch(/required/i);
+    });
+  });
+});