@oneuptime/common 12.0.13 → 12.0.14

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

@@ -0,0 +1,403 @@
+import MergeJSON from "../../../../../Server/Types/Workflow/Components/JSON/MergeJson";
+import {
+  RunOptions,
+  RunReturnType,
+} from "../../../../../Server/Types/Workflow/ComponentCode";
+import Exception from "../../../../../Types/Exception/Exception";
+import { JSONObject } from "../../../../../Types/JSON";
+import ObjectID from "../../../../../Types/ObjectID";
+import ComponentMetadata, {
+  Port,
+} from "../../../../../Types/Workflow/Component";
+import ComponentID from "../../../../../Types/Workflow/ComponentID";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Fixture bundling the RunOptions passed to a component together with the
+ * spy-able mocks embedded inside it, so a test can both drive the component and
+ * assert on how the component talked back through `onError` / `log`.
+ */
+interface OptionsFixture {
+  options: RunOptions;
+  onError: jest.Mock;
+  log: jest.Mock;
+}
+
+/*
+ * Build a deterministic RunOptions object. `onError` echoes the exception it is
+ * given (mirroring the real runner, which returns the exception so callers can
+ * `throw options.onError(...)`) while recording that it was invoked.
+ */
+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,
+  };
+}
+
+/*
+ * Convenience wrapper: run a fresh MergeJSON with the supplied args and return
+ * both the fixture (for `onError` assertions) and the promise, without awaiting,
+ * so error-path tests can use `expect(...).rejects`.
+ */
+function runMerge(args: JSONObject): {
+  fixture: OptionsFixture;
+  result: Promise<RunReturnType>;
+} {
+  const fixture: OptionsFixture = makeOptions();
+  const result: Promise<RunReturnType> = new MergeJSON().run(
+    args,
+    fixture.options,
+  );
+
+  return { fixture, result };
+}
+
+describe("MergeJSON constructor and metadata", () => {
+  test("wires up the Merge JSON component metadata", () => {
+    const component: MergeJSON = new MergeJSON();
+    const metadata: ComponentMetadata = component.getMetadata();
+
+    expect(metadata.id).toBe(ComponentID.MergeJson);
+    expect(metadata.title).toBe("Merge JSON");
+  });
+
+  test("exposes both success and error out ports", () => {
+    const metadata: ComponentMetadata = new MergeJSON().getMetadata();
+    const portIds: Array<string> = metadata.outPorts.map((p: Port): string => {
+      return p.id;
+    });
+
+    expect(portIds).toContain("success");
+    expect(portIds).toContain("error");
+  });
+});
+
+describe("MergeJSON successful merges", () => {
+  test("merges two disjoint objects and routes to the success port", async () => {
+    const {
+      fixture,
+      result,
+    }: { fixture: OptionsFixture; result: Promise<RunReturnType> } = runMerge({
+      json1: { a: 1 },
+      json2: { b: 2 },
+    });
+
+    const value: RunReturnType = await result;
+
+    expect(value.executePort?.id).toBe("success");
+    expect(value.returnValues).toEqual({ json: { a: 1, b: 2 } });
+    expect(fixture.onError).not.toHaveBeenCalled();
+  });
+
+  test("gives json2 precedence over json1 on conflicting keys", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: { shared: "from-json1", onlyOne: 1 },
+      json2: { shared: "from-json2", onlyTwo: 2 },
+    }).result;
+
+    expect(value.returnValues["json"]).toEqual({
+      shared: "from-json2",
+      onlyOne: 1,
+      onlyTwo: 2,
+    });
+  });
+
+  test("performs a shallow merge so a nested value from json2 fully replaces json1", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: { user: { name: "alice", age: 30 } },
+      json2: { user: { name: "bob" } },
+    }).result;
+
+    /*
+     * A deep merge would keep `age`; the spread-based implementation replaces
+     * the whole nested object, so only json2's `user` survives.
+     */
+    expect(value.returnValues["json"]).toEqual({ user: { name: "bob" } });
+  });
+
+  test("returns an empty object when both inputs are empty objects", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: {},
+      json2: {},
+    }).result;
+
+    expect(value.returnValues).toEqual({ json: {} });
+    expect(value.executePort?.id).toBe("success");
+  });
+
+  test("keeps every key when one input is empty", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: {},
+      json2: { only: "json2" },
+    }).result;
+
+    expect(value.returnValues["json"]).toEqual({ only: "json2" });
+  });
+
+  test("does not mutate the returned json to share a reference with either input", async () => {
+    const json1: JSONObject = { a: 1 };
+    const json2: JSONObject = { b: 2 };
+    const value: RunReturnType = await runMerge({ json1, json2 }).result;
+
+    expect(value.returnValues["json"]).not.toBe(json1);
+    expect(value.returnValues["json"]).not.toBe(json2);
+  });
+});
+
+describe("MergeJSON string inputs parsed as JSON", () => {
+  test("parses json1 supplied as a JSON string before merging", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: '{"a":1}',
+      json2: { b: 2 },
+    }).result;
+
+    expect(value.returnValues["json"]).toEqual({ a: 1, b: 2 });
+    expect(value.executePort?.id).toBe("success");
+  });
+
+  test("parses both json1 and json2 when both are JSON strings", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: '{"a":1}',
+      json2: '{"b":2}',
+    }).result;
+
+    expect(value.returnValues["json"]).toEqual({ a: 1, b: 2 });
+  });
+
+  test("accepts lenient JSON5 syntax (single quotes, unquoted keys, trailing commas)", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: "{ a: 'one', }",
+      json2: "{ b: 'two', }",
+    }).result;
+
+    expect(value.returnValues["json"]).toEqual({ a: "one", b: "two" });
+  });
+
+  test("surfaces a raw parse error (not routed through onError) for malformed json1", async () => {
+    const {
+      fixture,
+      result,
+    }: { fixture: OptionsFixture; result: Promise<RunReturnType> } = runMerge({
+      json1: "{ this is not valid",
+      json2: { b: 2 },
+    });
+
+    await expect(result).rejects.toThrow();
+    /*
+     * The parse happens outside the onError-wrapped guards, so a bad JSON
+     * string escapes as a raw parser exception rather than being routed to the
+     * component's error port.
+     */
+    expect(fixture.onError).not.toHaveBeenCalled();
+  });
+});
+
+describe("MergeJSON json1 validation failures", () => {
+  test("rejects when json1 is undefined", async () => {
+    const {
+      fixture,
+      result,
+    }: { fixture: OptionsFixture; result: Promise<RunReturnType> } = runMerge({
+      json2: { b: 2 },
+    });
+
+    await expect(result).rejects.toThrow("JSON1 is undefined.");
+    expect(fixture.onError).toHaveBeenCalledTimes(1);
+  });
+
+  test("treats an empty string json1 as undefined", async () => {
+    const {
+      fixture,
+      result,
+    }: { fixture: OptionsFixture; result: Promise<RunReturnType> } = runMerge({
+      json1: "",
+      json2: { b: 2 },
+    });
+
+    await expect(result).rejects.toThrow("JSON1 is undefined.");
+    expect(fixture.onError).toHaveBeenCalled();
+  });
+
+  test("treats the falsy number 0 json1 as undefined", async () => {
+    const { result }: { result: Promise<RunReturnType> } = runMerge({
+      json1: 0,
+      json2: { b: 2 },
+    });
+
+    await expect(result).rejects.toThrow("JSON1 is undefined.");
+  });
+
+  test("treats a false json1 as undefined", async () => {
+    const { result }: { result: Promise<RunReturnType> } = runMerge({
+      json1: false,
+      json2: { b: 2 },
+    });
+
+    await expect(result).rejects.toThrow("JSON1 is undefined.");
+  });
+
+  test("rejects a non-object, non-string json1 with a type error", async () => {
+    const {
+      fixture,
+      result,
+    }: { fixture: OptionsFixture; result: Promise<RunReturnType> } = runMerge({
+      json1: 42,
+      json2: { b: 2 },
+    });
+
+    await expect(result).rejects.toThrow("JSON1 is should be of type object.");
+    expect(fixture.onError).toHaveBeenCalled();
+  });
+
+  test("rejects a json1 string that parses to a non-object", async () => {
+    const { result }: { result: Promise<RunReturnType> } = runMerge({
+      json1: "42",
+      json2: { b: 2 },
+    });
+
+    await expect(result).rejects.toThrow("JSON1 is should be of type object.");
+  });
+});
+
+describe("MergeJSON json2 validation failures", () => {
+  test("rejects when json2 is undefined", async () => {
+    const {
+      fixture,
+      result,
+    }: { fixture: OptionsFixture; result: Promise<RunReturnType> } = runMerge({
+      json1: { a: 1 },
+    });
+
+    await expect(result).rejects.toThrow("JSON2 is undefined.");
+    expect(fixture.onError).toHaveBeenCalledTimes(1);
+  });
+
+  test("treats an empty string json2 as undefined", async () => {
+    const { result }: { result: Promise<RunReturnType> } = runMerge({
+      json1: { a: 1 },
+      json2: "",
+    });
+
+    await expect(result).rejects.toThrow("JSON2 is undefined.");
+  });
+
+  test("rejects a non-object, non-string json2 with a type error", async () => {
+    const {
+      fixture,
+      result,
+    }: { fixture: OptionsFixture; result: Promise<RunReturnType> } = runMerge({
+      json1: { a: 1 },
+      json2: 42,
+    });
+
+    await expect(result).rejects.toThrow("JSON2 is should be of type object.");
+    expect(fixture.onError).toHaveBeenCalled();
+  });
+
+  test("rejects a json2 string that parses to a non-object", async () => {
+    const { result }: { result: Promise<RunReturnType> } = runMerge({
+      json1: { a: 1 },
+      json2: "true",
+    });
+
+    await expect(result).rejects.toThrow("JSON2 is should be of type object.");
+  });
+});
+
+describe("MergeJSON validation ordering", () => {
+  test("reports the json1 failure first when both inputs are missing", async () => {
+    const { result }: { result: Promise<RunReturnType> } = runMerge({});
+
+    await expect(result).rejects.toThrow("JSON1 is undefined.");
+  });
+
+  test("only reaches the json2 checks once json1 is valid", async () => {
+    const { result }: { result: Promise<RunReturnType> } = runMerge({
+      json1: { a: 1 },
+    });
+
+    await expect(result).rejects.toThrow("JSON2 is undefined.");
+  });
+});
+
+describe("MergeJSON out-port guards", () => {
+  /*
+   * These guards live before any argument handling. They are normally
+   * unreachable because the real metadata always defines both ports, so we
+   * drive them by swapping in a metadata clone whose out ports are missing.
+   */
+  test("throws when the success port is missing from metadata", async () => {
+    const component: MergeJSON = new MergeJSON();
+    const base: ComponentMetadata = component.getMetadata();
+    component.setMetadata({
+      ...base,
+      outPorts: base.outPorts.filter((p: Port): boolean => {
+        return p.id !== "success";
+      }),
+    });
+
+    const fixture: OptionsFixture = makeOptions();
+
+    await expect(
+      component.run({ json1: { a: 1 }, json2: { b: 2 } }, fixture.options),
+    ).rejects.toThrow("Success port not found");
+    expect(fixture.onError).toHaveBeenCalled();
+  });
+
+  test("throws when the error port is missing from metadata", async () => {
+    const component: MergeJSON = new MergeJSON();
+    const base: ComponentMetadata = component.getMetadata();
+    component.setMetadata({
+      ...base,
+      outPorts: base.outPorts.filter((p: Port): boolean => {
+        return p.id !== "error";
+      }),
+    });
+
+    const fixture: OptionsFixture = makeOptions();
+
+    await expect(
+      component.run({ json1: { a: 1 }, json2: { b: 2 } }, fixture.options),
+    ).rejects.toThrow("Error port not found");
+    expect(fixture.onError).toHaveBeenCalled();
+  });
+});
+
+describe("MergeJSON array inputs", () => {
+  /*
+   * Arrays are truthy and `typeof [] === "object"`, so they pass the guards and
+   * get spread by index. This documents the real (arguably surprising)
+   * behavior rather than prescribing it.
+   */
+  test("spreads array inputs by numeric index into the merged object", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: ["x"],
+      json2: { a: 1 },
+    }).result;
+
+    expect(value.returnValues["json"]).toEqual({ "0": "x", a: 1 });
+  });
+
+  test("adds nothing for an empty array input", async () => {
+    const value: RunReturnType = await runMerge({
+      json1: { a: 1 },
+      json2: [],
+    }).result;
+
+    expect(value.returnValues["json"]).toEqual({ a: 1 });
+  });
+});

package/Tests/Server/Utils/Browser.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, test } from "@jest/globals";
+import BrowserUtil from "../../../Server/Utils/Browser";
+import ScreenSizeType from "../../../Types/ScreenSizeType";
+
+/*
+ * BrowserUtil.getViewportHeightAndWidth is a pure, synchronous lookup: it maps
+ * a ScreenSizeType enum value to a fixed viewport { height, width }. It has one
+ * switch case per enum member plus a default arm that mirrors Desktop.
+ *
+ * These tests pin every branch (Desktop, Mobile, Tablet, default), the exact
+ * pixel values each branch returns, and the shape/orientation invariants that
+ * downstream page.setViewportSize relies on. The function touches no network,
+ * no filesystem, no clock and no randomness, so every assertion is fully
+ * deterministic.
+ */
+
+interface Viewport {
+  height: number;
+  width: number;
+}
+
+function viewportFor(screenSizeType: ScreenSizeType): Viewport {
+  return BrowserUtil.getViewportHeightAndWidth({
+    screenSizeType: screenSizeType,
+  });
+}
+
+describe("BrowserUtil.getViewportHeightAndWidth", () => {
+  describe("per screen size branch", () => {
+    test("Desktop maps to 1920x1080 (landscape full HD)", () => {
+      const viewport: Viewport = viewportFor(ScreenSizeType.Desktop);
+
+      expect(viewport).toEqual({ height: 1080, width: 1920 });
+    });
+
+    test("Mobile maps to 360x640 (portrait handset)", () => {
+      const viewport: Viewport = viewportFor(ScreenSizeType.Mobile);
+
+      expect(viewport).toEqual({ height: 640, width: 360 });
+    });
+
+    test("Tablet maps to 1024x768", () => {
+      const viewport: Viewport = viewportFor(ScreenSizeType.Tablet);
+
+      expect(viewport).toEqual({ height: 768, width: 1024 });
+    });
+  });
+
+  describe("default / unknown branch", () => {
+    test("an unknown screen size falls through to the Desktop defaults", () => {
+      /*
+       * The switch has an explicit default arm that assigns the same 1080x1920
+       * as Desktop. It is only reachable with a value outside the enum, so we
+       * cast an arbitrary string through unknown to exercise it. If a future
+       * change forgets the default, this catches the resulting 0x0 viewport.
+       */
+      const viewport: Viewport = viewportFor(
+        "SomeUnsupportedSize" as unknown as ScreenSizeType,
+      );
+
+      expect(viewport).toEqual({ height: 1080, width: 1920 });
+    });
+
+    test("the default branch never returns the 0x0 initial values", () => {
+      const viewport: Viewport = viewportFor("" as unknown as ScreenSizeType);
+
+      expect(viewport.height).toBeGreaterThan(0);
+      expect(viewport.width).toBeGreaterThan(0);
+    });
+
+    test("default and Desktop are indistinguishable", () => {
+      const desktop: Viewport = viewportFor(ScreenSizeType.Desktop);
+      const unknown: Viewport = viewportFor(
+        "not-a-real-size" as unknown as ScreenSizeType,
+      );
+
+      expect(unknown).toEqual(desktop);
+    });
+  });
+
+  describe("shape and value invariants", () => {
+    const allSizes: Array<ScreenSizeType> = [
+      ScreenSizeType.Desktop,
+      ScreenSizeType.Mobile,
+      ScreenSizeType.Tablet,
+    ];
+
+    test("every enum member yields exactly a height and width", () => {
+      for (const size of allSizes) {
+        const viewport: Viewport = viewportFor(size);
+
+        expect(Object.keys(viewport).sort()).toEqual(["height", "width"]);
+      }
+    });
+
+    test("every dimension is a positive, finite integer", () => {
+      for (const size of allSizes) {
+        const viewport: Viewport = viewportFor(size);
+
+        for (const value of [viewport.height, viewport.width]) {
+          expect(Number.isInteger(value)).toBe(true);
+          expect(Number.isFinite(value)).toBe(true);
+          expect(value).toBeGreaterThan(0);
+        }
+      }
+    });
+
+    test("Mobile is the only portrait orientation; Desktop and Tablet are landscape", () => {
+      const mobile: Viewport = viewportFor(ScreenSizeType.Mobile);
+      const desktop: Viewport = viewportFor(ScreenSizeType.Desktop);
+      const tablet: Viewport = viewportFor(ScreenSizeType.Tablet);
+
+      expect(mobile.width).toBeLessThan(mobile.height);
+      expect(desktop.width).toBeGreaterThan(desktop.height);
+      expect(tablet.width).toBeGreaterThan(tablet.height);
+    });
+
+    test("Desktop is the largest surface and Mobile the smallest", () => {
+      const areaOf: (viewport: Viewport) => number = (
+        viewport: Viewport,
+      ): number => {
+        return viewport.height * viewport.width;
+      };
+
+      const desktopArea: number = areaOf(viewportFor(ScreenSizeType.Desktop));
+      const tabletArea: number = areaOf(viewportFor(ScreenSizeType.Tablet));
+      const mobileArea: number = areaOf(viewportFor(ScreenSizeType.Mobile));
+
+      expect(desktopArea).toBeGreaterThan(tabletArea);
+      expect(tabletArea).toBeGreaterThan(mobileArea);
+    });
+
+    test("the three known sizes are all distinct", () => {
+      const serialized: Array<string> = allSizes.map(
+        (size: ScreenSizeType): string => {
+          return JSON.stringify(viewportFor(size));
+        },
+      );
+
+      expect(new Set(serialized).size).toBe(allSizes.length);
+    });
+  });
+
+  describe("purity and determinism", () => {
+    test("repeated calls with the same input return equal values", () => {
+      const first: Viewport = viewportFor(ScreenSizeType.Tablet);
+      const second: Viewport = viewportFor(ScreenSizeType.Tablet);
+
+      expect(second).toEqual(first);
+    });
+
+    test("each call returns a fresh object, so callers cannot corrupt later results", () => {
+      const first: Viewport = viewportFor(ScreenSizeType.Desktop);
+      first.height = -1;
+      first.width = -1;
+
+      const second: Viewport = viewportFor(ScreenSizeType.Desktop);
+
+      expect(second).toEqual({ height: 1080, width: 1920 });
+    });
+  });
+});