@oneuptime/common 12.0.10 → 12.0.12

package/Tests/Server/Types/Workflow/Components/CustomCodeScriptError.test.ts

@@ -0,0 +1,121 @@
+import JavaScriptCode from "../../../../../Server/Types/Workflow/Components/JavaScript";
+import IfElse from "../../../../../Server/Types/Workflow/Components/Conditions/IfElse";
+import {
+  RunOptions,
+  RunReturnType,
+} from "../../../../../Server/Types/Workflow/ComponentCode";
+import VMUtil from "../../../../../Server/Utils/VM/VMAPI";
+import ReturnResult from "../../../../../Types/IsolatedVM/ReturnResult";
+import Exception from "../../../../../Types/Exception/Exception";
+import ObjectID from "../../../../../Types/ObjectID";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+interface OptionsFixture {
+  options: RunOptions;
+  log: jest.Mock;
+  onError: jest.Mock;
+}
+
+function makeOptions(): OptionsFixture {
+  const log: jest.Mock = jest.fn();
+  const onError: jest.Mock = jest.fn((exception: Exception): Exception => {
+    return exception;
+  });
+
+  return {
+    log,
+    onError,
+    options: {
+      log: log as RunOptions["log"],
+      workflowLogId: ObjectID.generate(),
+      workflowId: ObjectID.generate(),
+      projectId: ObjectID.generate(),
+      onError: onError as RunOptions["onError"],
+      executeWorkflow: async (): Promise<void> => {},
+    } as RunOptions,
+  };
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("Custom JavaScript component scriptError routing", () => {
+  test("routes to the error port when the sandbox resolves with scriptError", async () => {
+    const sandboxResult: ReturnResult = {
+      returnValue: undefined,
+      logMessages: ["before failure"],
+      capturedMetrics: [],
+      scriptError: new Error("script exploded"),
+    };
+    jest.spyOn(VMUtil, "runCodeInSandbox").mockResolvedValue(sandboxResult);
+
+    const { options, log }: OptionsFixture = makeOptions();
+    const result: RunReturnType = await new JavaScriptCode().run(
+      { code: "throw new Error('script exploded');" },
+      options,
+    );
+
+    expect(result.executePort?.id).toBe("error");
+    expect(log).toHaveBeenCalledWith("before failure");
+    expect(log).toHaveBeenCalledWith("Error running script");
+    expect(log).toHaveBeenCalledWith("script exploded");
+  });
+
+  test("routes to the success port with the return value on success", async () => {
+    const sandboxResult: ReturnResult = {
+      returnValue: { answer: 42 },
+      logMessages: [],
+      capturedMetrics: [],
+    };
+    jest.spyOn(VMUtil, "runCodeInSandbox").mockResolvedValue(sandboxResult);
+
+    const { options }: OptionsFixture = makeOptions();
+    const result: RunReturnType = await new JavaScriptCode().run(
+      { code: "return { answer: 42 };" },
+      options,
+    );
+
+    expect(result.executePort?.id).toBe("success");
+    expect(result.returnValues).toEqual({ returnValue: { answer: 42 } });
+  });
+});
+
+describe("If/Else component scriptError handling", () => {
+  test("fails the run instead of silently taking a branch when the expression errors", async () => {
+    const sandboxResult: ReturnResult = {
+      returnValue: undefined,
+      logMessages: [],
+      capturedMetrics: [],
+      scriptError: new Error("expression exploded"),
+    };
+    jest.spyOn(VMUtil, "runCodeInSandbox").mockResolvedValue(sandboxResult);
+
+    const { options, onError }: OptionsFixture = makeOptions();
+
+    await expect(
+      new IfElse().run(
+        { "input-1": "a", "input-2": "b", operator: "==" },
+        options,
+      ),
+    ).rejects.toThrow("expression exploded");
+    expect(onError).toHaveBeenCalled();
+  });
+
+  test("takes the Yes branch when the expression evaluates truthy", async () => {
+    const sandboxResult: ReturnResult = {
+      returnValue: true,
+      logMessages: [],
+      capturedMetrics: [],
+    };
+    jest.spyOn(VMUtil, "runCodeInSandbox").mockResolvedValue(sandboxResult);
+
+    const { options }: OptionsFixture = makeOptions();
+    const result: RunReturnType = await new IfElse().run(
+      { "input-1": "a", "input-2": "a", operator: "==" },
+      options,
+    );
+
+    expect(result.executePort?.id).toBe("yes");
+  });
+});

package/Tests/Server/Utils/Monitor/MonitorCriteriaEvaluatorJavascriptExpression.test.ts

@@ -0,0 +1,92 @@
+import MonitorCriteriaEvaluator from "../../../../Server/Utils/Monitor/MonitorCriteriaEvaluator";
+import VMUtil from "../../../../Server/Utils/VM/VMAPI";
+import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import MonitorStep from "../../../../Types/Monitor/MonitorStep";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import MonitorType from "../../../../Types/Monitor/MonitorType";
+import ReturnResult from "../../../../Types/IsolatedVM/ReturnResult";
+import ObjectID from "../../../../Types/ObjectID";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+type EvaluatorPrivate = {
+  isMonitorInstanceCriteriaFilterMet: (input: {
+    dataToProcess: unknown;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+    probeApiIngestResponse: unknown;
+    criteriaInstance: unknown;
+    criteriaFilter: CriteriaFilter;
+  }) => Promise<string | null>;
+};
+
+const Evaluator: EvaluatorPrivate =
+  MonitorCriteriaEvaluator as unknown as EvaluatorPrivate;
+
+function makeInput(): Parameters<
+  EvaluatorPrivate["isMonitorInstanceCriteriaFilterMet"]
+>[0] {
+  const monitor: Monitor = new Monitor();
+  monitor.projectId = ObjectID.generate();
+  monitor.monitorType = MonitorType.Ping;
+
+  return {
+    dataToProcess: { isOnline: true },
+    monitorStep: new MonitorStep(),
+    monitor,
+    probeApiIngestResponse: {},
+    criteriaInstance: {},
+    criteriaFilter: {
+      checkOn: CheckOn.JavaScriptExpression,
+      value: "1 === 1",
+    } as CriteriaFilter,
+  };
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("MonitorCriteriaEvaluator JavaScript expression criteria", () => {
+  test("treats a sandbox scriptError as criteria not met", async () => {
+    const sandboxResult: ReturnResult = {
+      returnValue: undefined,
+      logMessages: [],
+      capturedMetrics: [],
+      scriptError: new Error("expression exploded"),
+    };
+    jest.spyOn(VMUtil, "runCodeInSandbox").mockResolvedValue(sandboxResult);
+
+    const result: string | null =
+      await Evaluator.isMonitorInstanceCriteriaFilterMet(makeInput());
+
+    expect(result).toBeNull();
+  });
+
+  test("reports the criteria as met when the expression evaluates truthy", async () => {
+    const sandboxResult: ReturnResult = {
+      returnValue: true,
+      logMessages: [],
+      capturedMetrics: [],
+    };
+    jest.spyOn(VMUtil, "runCodeInSandbox").mockResolvedValue(sandboxResult);
+
+    const result: string | null =
+      await Evaluator.isMonitorInstanceCriteriaFilterMet(makeInput());
+
+    expect(result).toContain("evaluated to true");
+  });
+
+  test("treats a sandbox rejection as criteria not met", async () => {
+    jest
+      .spyOn(VMUtil, "runCodeInSandbox")
+      .mockRejectedValue(new Error("isolate crashed"));
+
+    const result: string | null =
+      await Evaluator.isMonitorInstanceCriteriaFilterMet(makeInput());
+
+    expect(result).toBeNull();
+  });
+});