@oneuptime/common 11.5.13 → 11.6.0

package/Tests/Utils/Array.test.ts

@@ -0,0 +1,156 @@
+import ArrayUtil from "../../Utils/Array";
+import ObjectID from "../../Types/ObjectID";
+
+describe("ArrayUtil", () => {
+  describe("removeDuplicates", () => {
+    it("keeps the first occurrence of each value in order", () => {
+      expect(ArrayUtil.removeDuplicates([1, 2, 2, 3, 1])).toEqual([1, 2, 3]);
+    });
+
+    it("returns an empty array unchanged", () => {
+      expect(ArrayUtil.removeDuplicates([])).toEqual([]);
+    });
+
+    it("de-duplicates strings", () => {
+      expect(ArrayUtil.removeDuplicates(["a", "b", "a"])).toEqual(["a", "b"]);
+    });
+  });
+
+  describe("mergeStringArrays", () => {
+    it("concatenates and removes duplicates", () => {
+      expect(ArrayUtil.mergeStringArrays(["a", "b"], ["b", "c"])).toEqual([
+        "a",
+        "b",
+        "c",
+      ]);
+    });
+
+    it("handles empty inputs on either side", () => {
+      expect(ArrayUtil.mergeStringArrays([], ["x"])).toEqual(["x"]);
+      expect(ArrayUtil.mergeStringArrays(["x"], [])).toEqual(["x"]);
+    });
+  });
+
+  describe("isEqual / isStringArrayEqual", () => {
+    it("is true for arrays with the same members regardless of order", () => {
+      expect(ArrayUtil.isEqual([1, 2, 3], [3, 2, 1])).toBe(true);
+      expect(ArrayUtil.isStringArrayEqual(["a", "b"], ["b", "a"])).toBe(true);
+    });
+
+    it("is false for different lengths", () => {
+      expect(ArrayUtil.isEqual([1, 2], [1, 2, 3])).toBe(false);
+    });
+
+    it("is false for different members", () => {
+      expect(ArrayUtil.isEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+    });
+
+    it("is true for two empty arrays", () => {
+      expect(ArrayUtil.isEqual([], [])).toBe(true);
+    });
+  });
+
+  describe("shuffle", () => {
+    it("returns a new array with the same members", () => {
+      const input: Array<number> = [1, 2, 3, 4, 5];
+      const shuffled: Array<number> = ArrayUtil.shuffle(input);
+      expect(shuffled).not.toBe(input);
+      expect([...shuffled].sort()).toEqual([...input].sort());
+    });
+
+    it("does not mutate the input array", () => {
+      const input: Array<number> = [1, 2, 3];
+      const copy: Array<number> = [...input];
+      ArrayUtil.shuffle(input);
+      expect(input).toEqual(copy);
+    });
+
+    it("handles empty and single-element arrays", () => {
+      expect(ArrayUtil.shuffle([])).toEqual([]);
+      expect(ArrayUtil.shuffle([9])).toEqual([9]);
+    });
+  });
+
+  describe("removeDuplicatesFromObjectIDArray", () => {
+    it("de-duplicates by string value", () => {
+      const id1: ObjectID = new ObjectID(
+        "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      );
+      const id1Dup: ObjectID = new ObjectID(
+        "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      );
+      const id2: ObjectID = new ObjectID(
+        "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+      );
+
+      const result: Array<ObjectID> =
+        ArrayUtil.removeDuplicatesFromObjectIDArray([id1, id1Dup, id2]);
+
+      expect(result).toHaveLength(2);
+      expect(
+        result.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      ).toEqual([id1.toString(), id2.toString()]);
+    });
+
+    it("returns an empty array unchanged", () => {
+      expect(ArrayUtil.removeDuplicatesFromObjectIDArray([])).toEqual([]);
+    });
+  });
+
+  describe("sortByFieldName", () => {
+    it("sorts objects ascending by the given field", () => {
+      const rows: Array<{ name: string; age: number }> = [
+        { name: "c", age: 3 },
+        { name: "a", age: 1 },
+        { name: "b", age: 2 },
+      ];
+      rows.sort(ArrayUtil.sortByFieldName("age"));
+      expect(
+        rows.map((r: { name: string }) => {
+          return r.name;
+        }),
+      ).toEqual(["a", "b", "c"]);
+    });
+
+    it("returns 0 for equal field values", () => {
+      const comparator: (a: any, b: any) => number =
+        ArrayUtil.sortByFieldName("age");
+      expect(comparator({ age: 5 }, { age: 5 })).toBe(0);
+    });
+  });
+
+  describe("selectItemByRandom", () => {
+    it("returns a member of the array", () => {
+      const arr: Array<string> = ["x", "y", "z"];
+      for (let i: number = 0; i < 100; i++) {
+        expect(arr).toContain(ArrayUtil.selectItemByRandom(arr));
+      }
+    });
+
+    it("returns the only element of a single-element array", () => {
+      expect(ArrayUtil.selectItemByRandom(["only"])).toBe("only");
+    });
+  });
+
+  describe("distinctByFieldName", () => {
+    it("keeps the first object for each distinct field value", () => {
+      const rows: Array<{ group: string; id: number }> = [
+        { group: "a", id: 1 },
+        { group: "b", id: 2 },
+        { group: "a", id: 3 },
+      ];
+      const result: Array<{ group: string; id: number }> =
+        ArrayUtil.distinctByFieldName(rows, "group");
+      expect(result).toEqual([
+        { group: "a", id: 1 },
+        { group: "b", id: 2 },
+      ]);
+    });
+
+    it("returns an empty array unchanged", () => {
+      expect(ArrayUtil.distinctByFieldName([], "group")).toEqual([]);
+    });
+  });
+});

package/Tests/Utils/CronTab.test.ts

@@ -0,0 +1,199 @@
+import CronTab, { CronPreset } from "../../Utils/CronTab";
+import cronParser from "cron-parser";
+
+/**
+ * These tests cross-check our dependency-free CronTab engine against
+ * `cron-parser` (the library BullMQ actually uses to fire repeatable jobs), so
+ * the picker's preview and validation stay faithful to real firing behavior.
+ */
+
+const FIXED_FROM: Date = new Date(Date.UTC(2026, 0, 1, 0, 0, 30));
+
+function cronParserNextTimes(
+  expression: string,
+  count: number,
+  from: Date,
+): Array<number> {
+  const interval: {
+    next: () => { toDate: () => Date };
+  } = cronParser.parseExpression(expression, {
+    currentDate: from,
+    tz: "UTC",
+  }) as unknown as { next: () => { toDate: () => Date } };
+
+  const times: Array<number> = [];
+  for (let i: number = 0; i < count; i++) {
+    times.push(interval.next().toDate().getTime());
+  }
+  return times;
+}
+
+describe("CronTab", () => {
+  describe("isVariableExpression", () => {
+    test("detects workflow variable references", () => {
+      expect(CronTab.isVariableExpression("{{local.variables.schedule}}")).toBe(
+        true,
+      );
+      expect(
+        CronTab.isVariableExpression("* */{{local.variables.h}} * * *"),
+      ).toBe(true);
+    });
+
+    test("returns false for plain cron expressions", () => {
+      expect(CronTab.isVariableExpression("0 */18 * * *")).toBe(false);
+      expect(CronTab.isVariableExpression("* * * * *")).toBe(false);
+    });
+  });
+
+  describe("validation", () => {
+    const validExpressions: Array<string> = [
+      "* * * * *",
+      "*/5 * * * *",
+      "0 */18 * * *",
+      "0 0 * * *",
+      "30 9 * * 1-5",
+      "0 0 1 */3 *",
+      "0 0 1 1 *",
+      "15,45 * * * *",
+      "0 0 * * MON",
+      "0 0 1 JAN *",
+      "0 0 * * 7",
+      "*/15 9-17 * * MON-FRI",
+      "30 2 * * * ", // trailing space
+      "0 0 * * SUN,SAT",
+      "5/10 * * * *",
+    ];
+
+    test.each(validExpressions)(
+      "accepts valid expression %s",
+      (expr: string) => {
+        expect(CronTab.getValidationError(expr)).toBeNull();
+        expect(CronTab.isValid(expr)).toBe(true);
+      },
+    );
+
+    const invalidExpressions: Array<string> = [
+      "",
+      "* * * *", // 4 fields
+      "* * * * * * *", // 7 fields
+      "60 * * * *", // minute out of range
+      "* 24 * * *", // hour out of range
+      "* * 32 * *", // dom out of range
+      "* * * 13 *", // month out of range
+      "* * * * 8", // dow out of range
+      "*/0 * * * *", // step 0
+      "abc * * * *", // not a number
+      "5-1 * * * *", // reversed range
+      "* * * * FUN", // bad day name
+    ];
+
+    test.each(invalidExpressions)(
+      "rejects invalid expression %s",
+      (expr: string) => {
+        expect(CronTab.getValidationError(expr)).not.toBeNull();
+        expect(CronTab.isValid(expr)).toBe(false);
+      },
+    );
+
+    test("variable expressions are not flagged as validation errors", () => {
+      expect(
+        CronTab.getValidationError("{{local.variables.schedule}}"),
+      ).toBeNull();
+      // ...but they are not "valid" concrete crons either.
+      expect(CronTab.isValid("{{local.variables.schedule}}")).toBe(false);
+    });
+  });
+
+  describe("all presets are valid and describable", () => {
+    test.each(
+      CronTab.PRESETS.map((p: CronPreset) => {
+        return p.value;
+      }),
+    )("preset %s", (value: string) => {
+      expect(CronTab.isValid(value)).toBe(true);
+      expect(CronTab.getHumanReadableDescription(value)).toBeTruthy();
+      // cron-parser must also accept it (guards against BullMQ rejecting).
+      expect(() => {
+        return cronParser.parseExpression(value, { tz: "UTC" });
+      }).not.toThrow();
+    });
+  });
+
+  describe("next execution times match cron-parser", () => {
+    const expressions: Array<string> = [
+      "* * * * *",
+      "*/5 * * * *",
+      "*/30 * * * *",
+      "0 * * * *",
+      "0 */3 * * *",
+      "0 */18 * * *",
+      "0 0 * * *",
+      "30 9 * * *",
+      "0 0 * * 0",
+      "0 0 * * 1-5",
+      "0 0 1 * *",
+      "0 0 1 */3 *",
+      "0 0 29 2 *", // leap-day only — sparse, exercises month/day jumps
+      "15,45 8-10 * * *",
+      "0 12 1,15 * *",
+    ];
+
+    test.each(expressions)("next 8 runs for %s", (expr: string) => {
+      const ours: Array<number> = CronTab.getNextExecutionTimes(
+        expr,
+        8,
+        FIXED_FROM,
+      ).map((d: Date) => {
+        return d.getTime();
+      });
+
+      const theirs: Array<number> = cronParserNextTimes(expr, 8, FIXED_FROM);
+
+      expect(ours).toEqual(theirs);
+    });
+  });
+
+  describe("human-readable descriptions", () => {
+    const cases: Array<[string, string]> = [
+      ["* * * * *", "Every minute"],
+      ["*/5 * * * *", "Every 5 minutes"],
+      ["*/30 * * * *", "Every 30 minutes"],
+      ["0 * * * *", "Every hour, on the hour"],
+      ["0 */2 * * *", "Every 2 hours"],
+      ["0 */18 * * *", "Every 18 hours"],
+      ["0 0 * * *", "Every day at 00:00 (UTC)"],
+      ["30 9 * * *", "Every day at 09:30 (UTC)"],
+      ["0 9 * * 1", "Every week on Monday at 09:00 (UTC)"],
+      ["0 0 * * 0", "Every week on Sunday at 00:00 (UTC)"],
+      ["0 0 1 * *", "Every month on the 1st at 00:00 (UTC)"],
+      ["0 0 1 */3 *", "Every 3 months on the 1st at 00:00 (UTC)"],
+      ["0 0 1 1 *", "On the 1st of January at 00:00 (UTC)"],
+    ];
+
+    test.each(cases)("describes %s as %s", (expr: string, expected: string) => {
+      expect(CronTab.getHumanReadableDescription(expr)).toBe(expected);
+    });
+
+    test("returns null for invalid expressions", () => {
+      expect(CronTab.getHumanReadableDescription("nonsense")).toBeNull();
+    });
+  });
+
+  describe("next execution times are in the future and ascending", () => {
+    test("returns the requested count in strictly increasing order", () => {
+      const times: Array<Date> = CronTab.getNextExecutionTimes(
+        "*/15 * * * *",
+        5,
+        FIXED_FROM,
+      );
+
+      expect(times).toHaveLength(5);
+      for (let i: number = 0; i < times.length; i++) {
+        expect(times[i]!.getTime()).toBeGreaterThan(FIXED_FROM.getTime());
+        if (i > 0) {
+          expect(times[i]!.getTime()).toBeGreaterThan(times[i - 1]!.getTime());
+        }
+      }
+    });
+  });
+});

package/Tests/Utils/ModelImportExport.test.ts

@@ -2,6 +2,7 @@ import Dashboard from "../../Models/DatabaseModels/Dashboard";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import ScheduledMaintenanceTemplate from "../../Models/DatabaseModels/ScheduledMaintenanceTemplate";
 import StatusPage from "../../Models/DatabaseModels/StatusPage";
+import Workflow from "../../Models/DatabaseModels/Workflow";
 import EventInterval from "../../Types/Events/EventInterval";
 import Recurring from "../../Types/Events/Recurring";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -86,6 +87,35 @@ describe("ModelImportExport", () => {
       expect(columns).not.toContain("embeddedOverallStatusToken");
     });
 
+    test("should include the workflow graph and its own settings", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Workflow);
+
+      expect(columns).toContain("name");
+      expect(columns).toContain("description");
+      expect(columns).toContain("graph");
+      expect(columns).toContain("isEnabled");
+    });
+
+    test("should exclude workflow secrets and server-derived trigger state", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Workflow);
+
+      /*
+       * These all carry create: [] access control - they are derived from the
+       * graph or generated on create, and re-importing them would either leak
+       * the source workflow's webhook secret or point the runner at stale
+       * trigger state.
+       */
+      expect(columns).not.toContain("webhookSecretKey");
+      expect(columns).not.toContain("triggerId");
+      expect(columns).not.toContain("triggerArguments");
+      expect(columns).not.toContain("repeatableJobKey");
+      expect(columns).not.toContain("slug");
+      expect(columns).not.toContain("projectId");
+      expect(columns).not.toContain("labels");
+    });
+
     test("should exclude monitor runtime-state columns", () => {
       const columns: Array<string> =
         ModelImportExport.getImportExportableColumnNames(Monitor);
@@ -267,6 +297,77 @@ describe("ModelImportExport", () => {
       expect(imported._id).toBeUndefined();
     });
 
+    test("should round-trip a workflow graph and drop its webhook secret", () => {
+      const graph: JSONObject = {
+        nodes: [
+          {
+            id: "node-1",
+            data: {
+              metadataId: "Webhook",
+              componentType: "Trigger",
+              nodeType: "Node",
+              arguments: {},
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const original: Workflow = new Workflow();
+      original.name = "Deploy Notifier";
+      original.description = "Posts to chat on deploy";
+      original.isEnabled = true;
+      original.graph = graph;
+      original.webhookSecretKey = "super-secret-key";
+      original.triggerId = "Webhook";
+      original.slug = "deploy-notifier";
+
+      const envelope: JSONObject = ModelImportExport.buildExportEnvelope({
+        modelType: Workflow,
+        items: [original],
+        exportedAt: new Date(),
+      });
+
+      const exported: JSONObject = (envelope["items"] as Array<JSONObject>)[0]!;
+
+      expect(exported["graph"]).toEqual(graph);
+      expect(exported["isEnabled"]).toBe(true);
+      expect(exported["webhookSecretKey"]).toBeUndefined();
+      expect(exported["triggerId"]).toBeUndefined();
+      expect(exported["slug"]).toBeUndefined();
+
+      const imported: Workflow = ModelImportExport.fromImportJSON({
+        json: exported,
+        modelType: Workflow,
+      });
+
+      expect(imported.name).toBe("Deploy Notifier");
+      expect(imported.description).toBe("Posts to chat on deploy");
+      expect(imported.graph).toEqual(graph);
+      expect(imported.webhookSecretKey).toBeUndefined();
+      expect(imported.triggerId).toBeUndefined();
+      expect(imported._id).toBeUndefined();
+    });
+
+    test("should import workflows disabled even when exported enabled", () => {
+      /*
+       * An imported workflow can reference resources that do not exist here,
+       * and enabling it starts it firing - so it must land disabled and be
+       * turned on deliberately.
+       */
+      const imported: Workflow = ModelImportExport.fromImportJSON({
+        json: {
+          name: "Pager Escalation",
+          isEnabled: true,
+          graph: { nodes: [], edges: [] },
+        },
+        modelType: Workflow,
+      });
+
+      expect(imported.name).toBe("Pager Escalation");
+      expect(imported.isEnabled).toBe(false);
+    });
+
     test("should advance past recurring dates for scheduled maintenance templates", () => {
       const dayInMs: number = 24 * 60 * 60 * 1000;
 

package/Tests/Utils/Number.test.ts

@@ -0,0 +1,179 @@
+import NumberUtil from "../../Utils/Number";
+
+describe("NumberUtil", () => {
+  describe("parseNumberWithDefault", () => {
+    it("parses a plain integer string", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({ value: "42", defaultValue: 0 }),
+      ).toBe(42);
+    });
+
+    it("falls back to the default for undefined, null and empty input", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({
+          value: undefined,
+          defaultValue: 7,
+        }),
+      ).toBe(7);
+      expect(
+        NumberUtil.parseNumberWithDefault({
+          value: null as unknown as undefined,
+          defaultValue: 7,
+        }),
+      ).toBe(7);
+      expect(
+        NumberUtil.parseNumberWithDefault({ value: "", defaultValue: 7 }),
+      ).toBe(7);
+    });
+
+    it("falls back to the default for non-numeric input", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({
+          value: "not-a-number",
+          defaultValue: 5,
+        }),
+      ).toBe(5);
+    });
+
+    it("parses the leading integer of a mixed string, like parseInt", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({ value: "12px", defaultValue: 0 }),
+      ).toBe(12);
+    });
+
+    it("truncates a decimal string to its integer part", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({ value: "3.9", defaultValue: 0 }),
+      ).toBe(3);
+    });
+
+    it("returns the default when the parsed value is below min", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({
+          value: "2",
+          defaultValue: 10,
+          min: 5,
+        }),
+      ).toBe(10);
+    });
+
+    it("returns the default when the parsed value is above max", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({
+          value: "200",
+          defaultValue: 10,
+          max: 100,
+        }),
+      ).toBe(10);
+    });
+
+    it("accepts a value exactly on the min and max boundaries", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({
+          value: "5",
+          defaultValue: 0,
+          min: 5,
+          max: 5,
+        }),
+      ).toBe(5);
+    });
+
+    it("accepts negative values within range", () => {
+      expect(
+        NumberUtil.parseNumberWithDefault({
+          value: "-3",
+          defaultValue: 0,
+          min: -10,
+        }),
+      ).toBe(-3);
+    });
+  });
+
+  describe("getRandomNumber", () => {
+    it("stays within the inclusive range across many draws", () => {
+      for (let i: number = 0; i < 1000; i++) {
+        const n: number = NumberUtil.getRandomNumber(3, 7);
+        expect(n).toBeGreaterThanOrEqual(3);
+        expect(n).toBeLessThanOrEqual(7);
+        expect(Number.isInteger(n)).toBe(true);
+      }
+    });
+
+    it("returns the single value when min equals max", () => {
+      expect(NumberUtil.getRandomNumber(4, 4)).toBe(4);
+    });
+  });
+
+  describe("convertToTwoDecimalPlaces", () => {
+    it("rounds to two decimal places", () => {
+      expect(NumberUtil.convertToTwoDecimalPlaces(3.14159)).toBe(3.14);
+      expect(NumberUtil.convertToTwoDecimalPlaces(2.005)).toBe(2.01);
+    });
+
+    it("leaves whole numbers unchanged", () => {
+      expect(NumberUtil.convertToTwoDecimalPlaces(10)).toBe(10);
+    });
+
+    it("rounds negative numbers", () => {
+      expect(NumberUtil.convertToTwoDecimalPlaces(-1.239)).toBe(-1.24);
+    });
+  });
+
+  describe("isNumber", () => {
+    it("is true for numeric values and numeric strings", () => {
+      expect(NumberUtil.isNumber(5)).toBe(true);
+      expect(NumberUtil.isNumber("5")).toBe(true);
+      expect(NumberUtil.isNumber(0)).toBe(true);
+    });
+
+    it("is false for non-numeric strings", () => {
+      expect(NumberUtil.isNumber("abc")).toBe(false);
+    });
+  });
+
+  describe("convertToNumber / canBeConvertedToNumber", () => {
+    it("converts numeric strings", () => {
+      expect(NumberUtil.convertToNumber("42")).toBe(42);
+      expect(NumberUtil.convertToNumber("3.5")).toBe(3.5);
+    });
+
+    it("reports whether a value can be converted", () => {
+      expect(NumberUtil.canBeConvertedToNumber("42")).toBe(true);
+      expect(NumberUtil.canBeConvertedToNumber("nope")).toBe(false);
+    });
+  });
+
+  describe("isInteger / isFloat", () => {
+    it("distinguishes integers from floats", () => {
+      expect(NumberUtil.isInteger(4)).toBe(true);
+      expect(NumberUtil.isInteger(4.5)).toBe(false);
+      expect(NumberUtil.isFloat(4.5)).toBe(true);
+      expect(NumberUtil.isFloat(4)).toBe(false);
+    });
+  });
+
+  describe("sign helpers", () => {
+    it("classifies positive, negative and zero", () => {
+      expect(NumberUtil.isPositive(1)).toBe(true);
+      expect(NumberUtil.isPositive(0)).toBe(false);
+      expect(NumberUtil.isNegative(-1)).toBe(true);
+      expect(NumberUtil.isNegative(0)).toBe(false);
+      expect(NumberUtil.isZero(0)).toBe(true);
+      expect(NumberUtil.isZero(1)).toBe(false);
+    });
+  });
+
+  describe("parity helpers", () => {
+    it("classifies even and odd", () => {
+      expect(NumberUtil.isEven(2)).toBe(true);
+      expect(NumberUtil.isEven(3)).toBe(false);
+      expect(NumberUtil.isOdd(3)).toBe(true);
+      expect(NumberUtil.isOdd(2)).toBe(false);
+    });
+
+    it("treats zero as even", () => {
+      expect(NumberUtil.isEven(0)).toBe(true);
+      expect(NumberUtil.isOdd(0)).toBe(false);
+    });
+  });
+});