@oneuptime/common 13.0.6 → 13.0.8

package/Tests/Types/SecurityEvent/SigmaRule.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  SIGMA_DEFAULT_LEVEL,
+  SIGMA_LEVEL_TO_OCSF_SEVERITY,
+  SIGMA_SUPPORTED_MODIFIERS,
+  SigmaLevel,
+  isSevereSigmaLevel,
+} from "../../../Types/SecurityEvent/SigmaRule";
+import OcsfSeverity, {
+  OcsfSeverityId,
+} from "../../../Types/SecurityEvent/OcsfSeverity";
+import {
+  DETECTION_EVALUATION_INTERVAL_MAX_IN_MINUTES,
+  DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES,
+  DETECTION_MAX_GROUPS_PER_EVALUATION,
+  DETECTION_MAX_LOOKBACK_IN_MINUTES,
+} from "../../../Types/SecurityEvent/DetectionFindingConstants";
+import {
+  THREAT_INTEL_DEFAULT_POLL_INTERVAL_IN_MINUTES,
+  THREAT_INTEL_FIRST_MATCH_WINDOW_IN_MINUTES,
+  THREAT_INTEL_MATCH_MAX_LOOKBACK_IN_MINUTES,
+  THREAT_INTEL_MAX_INDICATORS_PER_EVALUATION,
+  THREAT_INTEL_POLL_INTERVAL_MAX_IN_MINUTES,
+  THREAT_INTEL_POLL_INTERVAL_MIN_IN_MINUTES,
+} from "../../../Types/SecurityEvent/ThreatIntelConstants";
+
+/*
+ * The Sigma level map, modifier list and engine limits used to be private
+ * to the evaluator, parser and matcher. They now live in Types so the
+ * dashboard's guides can render them — which makes them a contract, and
+ * these are its invariants.
+ */
+
+const LEVELS_IN_RISING_ORDER: Array<SigmaLevel> = [
+  SigmaLevel.Informational,
+  SigmaLevel.Low,
+  SigmaLevel.Medium,
+  SigmaLevel.High,
+  SigmaLevel.Critical,
+];
+
+describe("SIGMA_LEVEL_TO_OCSF_SEVERITY", () => {
+  test("maps every Sigma level", () => {
+    expect(Object.keys(SIGMA_LEVEL_TO_OCSF_SEVERITY).sort()).toEqual(
+      Object.values(SigmaLevel).sort(),
+    );
+  });
+
+  test("maps each level to the OCSF severity of the same name", () => {
+    expect(SIGMA_LEVEL_TO_OCSF_SEVERITY).toEqual({
+      [SigmaLevel.Informational]: OcsfSeverity.Informational,
+      [SigmaLevel.Low]: OcsfSeverity.Low,
+      [SigmaLevel.Medium]: OcsfSeverity.Medium,
+      [SigmaLevel.High]: OcsfSeverity.High,
+      [SigmaLevel.Critical]: OcsfSeverity.Critical,
+    });
+  });
+
+  test("a more severe level never maps to a less severe OCSF severity", () => {
+    const ids: Array<number> = LEVELS_IN_RISING_ORDER.map(
+      (level: SigmaLevel): number => {
+        return OcsfSeverityId[SIGMA_LEVEL_TO_OCSF_SEVERITY[level]];
+      },
+    );
+
+    for (let index: number = 1; index < ids.length; index++) {
+      expect(ids[index]!).toBeGreaterThan(ids[index - 1]!);
+    }
+  });
+});
+
+describe("isSevereSigmaLevel", () => {
+  test.each(LEVELS_IN_RISING_ORDER)("%s", (level: SigmaLevel) => {
+    expect(isSevereSigmaLevel(level)).toBe(
+      level === SigmaLevel.High || level === SigmaLevel.Critical,
+    );
+  });
+});
+
+describe("SIGMA_DEFAULT_LEVEL", () => {
+  test("is a real level, and the middle one", () => {
+    expect(Object.values(SigmaLevel)).toContain(SIGMA_DEFAULT_LEVEL);
+    expect(SIGMA_DEFAULT_LEVEL).toBe(SigmaLevel.Medium);
+  });
+});
+
+describe("SIGMA_SUPPORTED_MODIFIERS", () => {
+  test("has no duplicates and only lowercase names, as the parser lowercases input", () => {
+    expect(new Set(SIGMA_SUPPORTED_MODIFIERS).size).toBe(
+      SIGMA_SUPPORTED_MODIFIERS.length,
+    );
+
+    for (const modifier of SIGMA_SUPPORTED_MODIFIERS) {
+      expect(modifier).toBe(modifier.toLowerCase());
+    }
+  });
+});
+
+describe("engine limits", () => {
+  test("detection rule interval bounds are ordered and whole", () => {
+    expect(Number.isInteger(DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES)).toBe(
+      true,
+    );
+    expect(DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES).toBeGreaterThanOrEqual(
+      1,
+    );
+    expect(DETECTION_EVALUATION_INTERVAL_MAX_IN_MINUTES).toBeGreaterThan(
+      DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES,
+    );
+  });
+
+  test("a rule at its longest interval still fits in one lookback", () => {
+    expect(DETECTION_MAX_LOOKBACK_IN_MINUTES).toBeGreaterThanOrEqual(
+      DETECTION_EVALUATION_INTERVAL_MAX_IN_MINUTES,
+    );
+  });
+
+  test("threat intel's default poll interval is inside its bounds", () => {
+    expect(
+      THREAT_INTEL_DEFAULT_POLL_INTERVAL_IN_MINUTES,
+    ).toBeGreaterThanOrEqual(THREAT_INTEL_POLL_INTERVAL_MIN_IN_MINUTES);
+    expect(THREAT_INTEL_DEFAULT_POLL_INTERVAL_IN_MINUTES).toBeLessThanOrEqual(
+      THREAT_INTEL_POLL_INTERVAL_MAX_IN_MINUTES,
+    );
+  });
+
+  test("the matcher's first window fits inside its lookback cap", () => {
+    expect(THREAT_INTEL_FIRST_MATCH_WINDOW_IN_MINUTES).toBeLessThanOrEqual(
+      THREAT_INTEL_MATCH_MAX_LOOKBACK_IN_MINUTES,
+    );
+  });
+
+  test("per-run caps are positive whole numbers", () => {
+    for (const cap of [
+      DETECTION_MAX_GROUPS_PER_EVALUATION,
+      THREAT_INTEL_MAX_INDICATORS_PER_EVALUATION,
+    ]) {
+      expect(Number.isInteger(cap)).toBe(true);
+      expect(cap).toBeGreaterThan(0);
+    }
+  });
+});

package/Tests/Types/WebsiteRequest.test.ts

@@ -272,6 +272,50 @@ describe("WebsiteRequest.fetch", () => {
     expect(budget.remainingBytes).toBe(100 - Buffer.byteLength(bodyText));
   });
 
+  test.each([200, 400, 503])(
+    "should cancel a stalled status %s body even after Axios has settled",
+    async (status: number) => {
+      const controller: AbortController = new AbortController();
+      let resolveReading: () => void = (): void => {};
+      const reading: Promise<void> = new Promise((resolve: () => void) => {
+        resolveReading = resolve;
+      });
+      const body: Readable = new Readable({
+        read: (): void => {
+          resolveReading();
+        },
+      });
+      const response: {
+        status: number;
+        data: Readable;
+        headers: Record<string, string>;
+      } = { status: status, data: body, headers: {} };
+      if (status >= 400) {
+        axiosMock.mockRejectedValueOnce({
+          isAxiosError: true,
+          response: response,
+        });
+      } else {
+        axiosMock.mockResolvedValueOnce(response);
+      }
+
+      const pending: Promise<WebsiteResponse> = WebsiteRequest.fetch(url, {
+        signal: controller.signal,
+        responseBodyBudget: new HTTPResponseBodyBudget(100),
+      });
+      const rejected: Promise<void> = expect(pending).rejects.toMatchObject({
+        name: "AbortError",
+      });
+
+      await reading;
+      controller.abort();
+      await rejected;
+
+      expect(body.destroyed).toBe(true);
+      expect(axiosMock).toHaveBeenCalledTimes(1);
+    },
+  );
+
   test("should strip a leading UTF-8 BOM from a budgeted HTML stream", async () => {
     const html: string = "<html><body>bounded</body></html>";
     const bodyText: string = `\uFEFF${html}`;

package/Tests/Types/Workflow/Components/JSON.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, test } from "@jest/globals";
+import JsonComponents from "../../../../Types/Workflow/Components/JSON";
+import AllComponents from "../../../../Types/Workflow/Components";
+import ComponentID from "../../../../Types/Workflow/ComponentID";
+import ComponentMetadata, {
+  Argument,
+  ComponentInputType,
+  ComponentType,
+  Port,
+  ReturnValue,
+} from "../../../../Types/Workflow/Component";
+import IconProp from "../../../../Types/Icon/IconProp";
+
+/*
+ * The JSON workflow block catalog. The server-side runners
+ * (Server/Types/Workflow/Components/JSON/*) look their metadata up here by
+ * ComponentID and then read args / emit return values / choose ports by the
+ * ids declared below, so a renamed id silently breaks saved workflows.
+ */
+
+const findComponent: (id: ComponentID) => ComponentMetadata = (
+  id: ComponentID,
+): ComponentMetadata => {
+  const component: ComponentMetadata | undefined = JsonComponents.find(
+    (item: ComponentMetadata) => {
+      return item.id === id;
+    },
+  );
+  if (!component) {
+    throw new Error(`Component ${id} not found`);
+  }
+  return component;
+};
+
+const argumentIds: (component: ComponentMetadata) => Array<string> = (
+  component: ComponentMetadata,
+): Array<string> => {
+  return component.arguments.map((argument: Argument) => {
+    return argument.id;
+  });
+};
+
+const returnValueIds: (component: ComponentMetadata) => Array<string> = (
+  component: ComponentMetadata,
+): Array<string> => {
+  return component.returnValues.map((returnValue: ReturnValue) => {
+    return returnValue.id;
+  });
+};
+
+const portIds: (ports: Array<Port>) => Array<string> = (
+  ports: Array<Port>,
+): Array<string> => {
+  return ports.map((port: Port) => {
+    return port.id;
+  });
+};
+
+describe("Workflow JSON components", () => {
+  test("exports exactly the three JSON blocks in order", () => {
+    expect(
+      JsonComponents.map((component: ComponentMetadata) => {
+        return component.id;
+      }),
+    ).toEqual([
+      ComponentID.JsonToText,
+      ComponentID.TextToJson,
+      ComponentID.MergeJson,
+    ]);
+  });
+
+  test("ids resolve to the expected stable string values", () => {
+    expect(ComponentID.JsonToText).toBe("json-to-text");
+    expect(ComponentID.TextToJson).toBe("text-to-json");
+    expect(ComponentID.MergeJson).toBe("merge-json");
+  });
+
+  test("component ids are unique", () => {
+    const ids: Array<string> = JsonComponents.map(
+      (component: ComponentMetadata) => {
+        return component.id;
+      },
+    );
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test.each(JsonComponents)(
+    "$id shares the JSON category, icon and component type",
+    (component: ComponentMetadata) => {
+      expect(component.category).toBe("JSON");
+      expect(component.iconProp).toBe(IconProp.JSON);
+      expect(component.componentType).toBe(ComponentType.Component);
+      expect(component.title.trim().length).toBeGreaterThan(0);
+      expect(component.description.trim().length).toBeGreaterThan(0);
+    },
+  );
+
+  test.each(JsonComponents)(
+    "$id has a single 'in' port and success / error out ports",
+    (component: ComponentMetadata) => {
+      expect(portIds(component.inPorts)).toEqual(["in"]);
+      expect(portIds(component.outPorts)).toEqual(["success", "error"]);
+      for (const port of [...component.inPorts, ...component.outPorts]) {
+        expect(port.title.length).toBeGreaterThan(0);
+        expect(port.description.length).toBeGreaterThan(0);
+      }
+    },
+  );
+
+  test.each(JsonComponents)(
+    "$id marks every argument and return value as required",
+    (component: ComponentMetadata) => {
+      for (const argument of component.arguments) {
+        expect(argument.required).toBe(true);
+      }
+      for (const returnValue of component.returnValues) {
+        expect(returnValue.required).toBe(true);
+      }
+    },
+  );
+
+  test.each(JsonComponents)(
+    "$id has unique argument and return value ids",
+    (component: ComponentMetadata) => {
+      const args: Array<string> = argumentIds(component);
+      const returns: Array<string> = returnValueIds(component);
+      expect(new Set(args).size).toBe(args.length);
+      expect(new Set(returns).size).toBe(returns.length);
+    },
+  );
+
+  test("JSON to Text takes JSON 'json' and returns Text 'text'", () => {
+    const component: ComponentMetadata = findComponent(ComponentID.JsonToText);
+    expect(component.title).toBe("JSON to Text");
+    expect(argumentIds(component)).toEqual(["json"]);
+    expect(component.arguments[0]!.type).toBe(ComponentInputType.JSON);
+    expect(returnValueIds(component)).toEqual(["text"]);
+    expect(component.returnValues[0]!.type).toBe(ComponentInputType.Text);
+  });
+
+  test("Text to JSON takes Text 'text' and returns JSON 'json'", () => {
+    const component: ComponentMetadata = findComponent(ComponentID.TextToJson);
+    expect(component.title).toBe("Text to JSON");
+    expect(argumentIds(component)).toEqual(["text"]);
+    expect(component.arguments[0]!.type).toBe(ComponentInputType.Text);
+    expect(returnValueIds(component)).toEqual(["json"]);
+    expect(component.returnValues[0]!.type).toBe(ComponentInputType.JSON);
+  });
+
+  test("Merge JSON takes two JSON args 'json1' / 'json2' and returns JSON 'json'", () => {
+    const component: ComponentMetadata = findComponent(ComponentID.MergeJson);
+    expect(component.title).toBe("Merge JSON");
+    expect(argumentIds(component)).toEqual(["json1", "json2"]);
+    for (const argument of component.arguments) {
+      expect(argument.type).toBe(ComponentInputType.JSON);
+    }
+    expect(
+      component.arguments.map((argument: Argument) => {
+        return argument.name;
+      }),
+    ).toEqual(["JSON 1", "JSON 2"]);
+    expect(returnValueIds(component)).toEqual(["json"]);
+    expect(component.returnValues[0]!.type).toBe(ComponentInputType.JSON);
+  });
+
+  test("every JSON block is registered in the global component catalog", () => {
+    for (const component of JsonComponents) {
+      expect(AllComponents).toContain(component);
+    }
+  });
+
+  test("no other workflow block reuses a JSON block id", () => {
+    for (const component of JsonComponents) {
+      const matches: Array<ComponentMetadata> = AllComponents.filter(
+        (item: ComponentMetadata) => {
+          return item.id === component.id;
+        },
+      );
+      expect(matches).toHaveLength(1);
+    }
+  });
+});

package/Tests/UI/Components/BasicFormDropdownNormalization.test.tsx

@@ -2,9 +2,10 @@ import BasicForm from "../../../UI/Components/Forms/BasicForm";
 import Fields from "../../../UI/Components/Forms/Types/Fields";
 import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
 import FormValues from "../../../UI/Components/Forms/Types/FormValues";
+import { FormStep } from "../../../UI/Components/Forms/Types/FormStep";
 import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
 import ObjectID from "../../../Types/ObjectID";
-import { render, screen } from "@testing-library/react";
+import { act, render, screen, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import * as React from "react";
 import { describe, expect, test } from "@jest/globals";
@@ -164,4 +165,118 @@ describe("BasicForm dropdown initial-value normalization", () => {
 
     expect(submitted["snmpVersion"]).toBeUndefined();
   });
+
+  test("preserves all multiselect IDs when available options contain only some selections", async () => {
+    const submitted: FormValues<any> = await submitForm(
+      { owners: ["unavailable-owner", "available-owner"] },
+      [
+        {
+          field: { owners: true },
+          title: "Owners",
+          fieldType: FormFieldSchemaType.MultiSelectDropdown,
+          dropdownOptions: [
+            { label: "Available Owner", value: "available-owner" },
+          ],
+        },
+      ],
+    );
+
+    expect(submitted["owners"]).toEqual([
+      "unavailable-owner",
+      "available-owner",
+    ]);
+  });
+
+  test("preserves and canonicalizes multiselect ObjectIDs before options load", async () => {
+    const firstId: ObjectID = new ObjectID(
+      "3f1b6b0e-0000-4000-8000-000000000003",
+    );
+    const secondId: ObjectID = new ObjectID(
+      "3f1b6b0e-0000-4000-8000-000000000004",
+    );
+    const submitted: FormValues<any> = await submitForm(
+      { owners: [firstId, secondId] } as unknown as FormValues<any>,
+      [
+        {
+          field: { owners: true },
+          title: "Owners",
+          fieldType: FormFieldSchemaType.MultiSelectDropdown,
+        },
+      ],
+    );
+
+    expect(submitted["owners"]).toEqual([
+      firstId.toString(),
+      secondId.toString(),
+    ]);
+  });
+
+  test("keeps saved owners visible and submitted when their step loads options after initialization", async () => {
+    const onSubmit: MockFunction = getJestMockFunction();
+    const ownerId: string = "3f1b6b0e-0000-4000-8000-000000000005";
+    let resolveOptions: (options: Array<DropdownOption>) => void = () => {};
+    const optionsLoaded: Promise<Array<DropdownOption>> = new Promise(
+      (resolve: (options: Array<DropdownOption>) => void) => {
+        resolveOptions = resolve;
+      },
+    );
+    const steps: Array<FormStep<FormValues<any>>> = [
+      { id: "details", title: "Details" },
+      { id: "owners", title: "Owner Settings" },
+    ];
+    const fields: Fields<FormValues<any>> = [
+      {
+        field: { title: true },
+        title: "Rule Title",
+        fieldType: FormFieldSchemaType.Text,
+        stepId: "details",
+      },
+      {
+        field: { owners: true },
+        title: "Owners",
+        fieldType: FormFieldSchemaType.MultiSelectDropdown,
+        stepId: "owners",
+        fetchDropdownOptions: async (): Promise<Array<DropdownOption>> => {
+          return optionsLoaded;
+        },
+      },
+    ];
+    const user: ReturnType<typeof userEvent.setup> = userEvent.setup({
+      delay: null,
+    });
+
+    render(
+      <BasicForm
+        fields={fields}
+        steps={steps}
+        initialValues={{ title: "Existing rule", owners: [ownerId] }}
+        onSubmit={onSubmit}
+        submitButtonText="Save"
+        disableAutofocus={true}
+      />,
+    );
+
+    await screen.findByRole("textbox", { name: /^Rule Title/ });
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await screen.findByRole("combobox", { name: /^Owners/ });
+    await act(async () => {
+      resolveOptions([{ label: "Saved Owner", value: ownerId }]);
+      await optionsLoaded;
+    });
+
+    expect(await screen.findByText("Saved Owner")).toBeTruthy();
+    await user.click(
+      within(screen.getByRole("navigation", { name: "Progress" })).getByText(
+        "Details",
+      ),
+    );
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    expect(await screen.findByText("Saved Owner")).toBeTruthy();
+    await user.click(screen.getByRole("button", { name: "Save" }));
+
+    expect(onSubmit.mock.calls[0]?.[0]).toEqual({
+      title: "Existing rule",
+      owners: [ownerId],
+    });
+  });
 });

package/Tests/UI/Components/Dropdown/DropdownAsyncOptions.test.tsx

@@ -0,0 +1,81 @@
+import Dropdown, {
+  DropdownOption,
+} from "../../../../UI/Components/Dropdown/Dropdown";
+import getJestMockFunction, { MockFunction } from "../../../MockType";
+import "@testing-library/jest-dom";
+import { render, RenderResult, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+
+describe("Dropdown asynchronous options", () => {
+  const owner: DropdownOption = { value: "owner-1", label: "Saved Owner" };
+
+  test("resolves a controlled multiselect's unchanged IDs when options arrive", () => {
+    const onChange: MockFunction = getJestMockFunction();
+    // BasicForm passes the stored IDs, before their option labels are fetched.
+    const value: Array<DropdownOption> = [
+      owner.value,
+    ] as unknown as Array<DropdownOption>;
+    const { rerender }: RenderResult = render(
+      <Dropdown
+        isMultiSelect={true}
+        options={[]}
+        value={value}
+        onChange={onChange}
+      />,
+    );
+
+    expect(screen.queryByText(owner.label)).not.toBeInTheDocument();
+    rerender(
+      <Dropdown
+        isMultiSelect={true}
+        options={[owner]}
+        value={value}
+        onChange={onChange}
+      />,
+    );
+
+    expect(screen.getByText(owner.label)).toBeVisible();
+    expect(
+      screen.getByRole("button", { name: "Remove Saved Owner" }),
+    ).toBeVisible();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  test("resolves a controlled single value when options arrive", () => {
+    const value: DropdownOption = owner.value as unknown as DropdownOption;
+    const { rerender }: RenderResult = render(
+      <Dropdown options={[]} value={value} />,
+    );
+
+    rerender(<Dropdown options={[owner]} value={value} />);
+
+    expect(screen.getByText(owner.label)).toBeVisible();
+  });
+
+  test("does not clear an uncontrolled selection when its options refresh", () => {
+    const { rerender }: RenderResult = render(
+      <Dropdown options={[owner]} initialValue={owner} />,
+    );
+
+    rerender(
+      <Dropdown
+        options={[owner, { value: "owner-2", label: "Another Owner" }]}
+        initialValue={owner}
+      />,
+    );
+
+    expect(screen.getByText(owner.label)).toBeVisible();
+    expect(screen.queryByText("Another Owner")).not.toBeInTheDocument();
+  });
+
+  test("still clears a controlled selection when its value becomes undefined", () => {
+    const { rerender }: RenderResult = render(
+      <Dropdown options={[owner]} value={owner} />,
+    );
+
+    rerender(<Dropdown options={[owner]} value={undefined} />);
+
+    expect(screen.queryByText(owner.label)).not.toBeInTheDocument();
+  });
+});