@oneuptime/common 11.4.0 → 11.5.0

package/Tests/Types/BaseDatabase/DatabaseCommonInteractionPropsUtil.test.ts

@@ -0,0 +1,152 @@
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import DatabaseCommonInteractionPropsUtil, {
+  PermissionType,
+} from "../../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
+import ObjectID from "../../../Types/ObjectID";
+import Permission, {
+  UserPermission,
+  UserTenantAccessPermission,
+} from "../../../Types/Permission";
+
+describe("DatabaseCommonInteractionPropsUtil.getUserPermissions", () => {
+  const makePerm: (
+    permission: Permission,
+    isBlockPermission: boolean,
+  ) => UserPermission = (
+    permission: Permission,
+    isBlockPermission: boolean,
+  ): UserPermission => {
+    return {
+      _type: "UserPermission",
+      permission,
+      labelIds: [],
+      isBlockPermission,
+    };
+  };
+
+  const permissionsOf: (result: Array<UserPermission>) => Array<Permission> = (
+    result: Array<UserPermission>,
+  ): Array<Permission> => {
+    return result.map((p: UserPermission): Permission => {
+      return p.permission;
+    });
+  };
+
+  describe("global permissions", () => {
+    test("always grants Public for an anonymous Allow request", () => {
+      const props: DatabaseCommonInteractionProps = {};
+
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.Public);
+    });
+
+    test("adds CurrentUser when a user is logged in", () => {
+      const props: DatabaseCommonInteractionProps = {
+        userId: ObjectID.generate(),
+      };
+
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.Public);
+      expect(perms).toContain(Permission.CurrentUser);
+    });
+
+    test("preserves existing global permissions and appends Public", () => {
+      const props: DatabaseCommonInteractionProps = {
+        userGlobalAccessPermission: {
+          _type: "UserGlobalAccessPermission",
+          projectIds: [],
+          globalPermissions: [Permission.ProjectOwner],
+        },
+      };
+
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.ProjectOwner);
+      expect(perms).toContain(Permission.Public);
+    });
+
+    test("does not include global permissions for a Block request", () => {
+      const props: DatabaseCommonInteractionProps = {};
+
+      expect(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Block,
+        ),
+      ).toEqual([]);
+    });
+  });
+
+  describe("tenant permissions", () => {
+    const buildTenantProps: () => {
+      props: DatabaseCommonInteractionProps;
+      tenantId: ObjectID;
+    } = (): {
+      props: DatabaseCommonInteractionProps;
+      tenantId: ObjectID;
+    } => {
+      const tenantId: ObjectID = ObjectID.generate();
+      const tenantPermission: UserTenantAccessPermission = {
+        _type: "UserTenantAccessPermission",
+        projectId: tenantId,
+        permissions: [
+          makePerm(Permission.ProjectMember, false), // allow row
+          makePerm(Permission.ProjectOwner, true), // block row
+        ],
+      };
+
+      return {
+        tenantId,
+        props: {
+          tenantId,
+          userTenantAccessPermission: {
+            [tenantId.toString()]: tenantPermission,
+          },
+        },
+      };
+    };
+
+    test("Allow includes the tenant's non-block permissions (plus global)", () => {
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          buildTenantProps().props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.ProjectMember); // allow tenant row
+      expect(perms).toContain(Permission.Public); // global
+      expect(perms).not.toContain(Permission.ProjectOwner); // block row excluded
+    });
+
+    test("Block includes only the tenant's block permissions", () => {
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          buildTenantProps().props,
+          PermissionType.Block,
+        ),
+      );
+
+      expect(perms).toContain(Permission.ProjectOwner); // block tenant row
+      expect(perms).not.toContain(Permission.ProjectMember); // allow row excluded
+      expect(perms).not.toContain(Permission.Public); // no global for Block
+    });
+  });
+});

package/Tests/Types/Monitor/MonitorType.test.ts

@@ -120,7 +120,7 @@ describe("MonitorTypeHelper", () => {
       MonitorType.SSLCertificate,
       MonitorType.SyntheticMonitor,
       MonitorType.CustomJavaScriptCode,
-      MonitorType.SNMP,
+      MonitorType.NetworkDevice,
       MonitorType.DNS,
       MonitorType.DNSSEC,
       MonitorType.Domain,

package/Tests/Types/Trace/TraceRecordingRuleDefinition.test.ts

@@ -0,0 +1,308 @@
+import TraceAggregationType from "../../../Types/Trace/TraceAggregationType";
+import TraceRecordingRuleDefinition, {
+  TraceRecordingRuleDefinitionUtil,
+  TraceRecordingRuleSource,
+  TraceRecordingRuleAttributeFilter,
+  TRACE_RECORDING_RULE_MAX_SOURCES,
+  TRACE_RECORDING_RULE_MAX_EXPRESSION_LENGTH,
+} from "../../../Types/Trace/TraceRecordingRuleDefinition";
+
+describe("TraceRecordingRuleDefinitionUtil", () => {
+  const makeSource: (
+    overrides?: Partial<TraceRecordingRuleSource>,
+  ) => TraceRecordingRuleSource = (
+    overrides: Partial<TraceRecordingRuleSource> = {},
+  ): TraceRecordingRuleSource => {
+    return {
+      alias: "A",
+      aggregationType: TraceAggregationType.Count,
+      ...overrides,
+    };
+  };
+
+  describe("getAggregationOptions", () => {
+    test("every option has a valid value, label and description", () => {
+      const options: Array<{
+        value: TraceAggregationType;
+        label: string;
+        description: string;
+      }> = TraceRecordingRuleDefinitionUtil.getAggregationOptions();
+
+      expect(options.length).toBeGreaterThan(0);
+      for (const option of options) {
+        expect(option.label.length).toBeGreaterThan(0);
+        expect(option.description.length).toBeGreaterThan(0);
+        expect(Object.values(TraceAggregationType)).toContain(option.value);
+      }
+    });
+  });
+
+  describe("getSpanKindOptions", () => {
+    test("includes an 'Any' option with an empty value", () => {
+      const options: Array<{ value: string; label: string }> =
+        TraceRecordingRuleDefinitionUtil.getSpanKindOptions();
+
+      expect(
+        options.some((o: { value: string }): boolean => {
+          return o.value === "";
+        }),
+      ).toBe(true);
+      expect(
+        options.some((o: { value: string }): boolean => {
+          return o.value === "SPAN_KIND_SERVER";
+        }),
+      ).toBe(true);
+    });
+  });
+
+  describe("getSourceAttributeFilters", () => {
+    test("returns the multi-filter entries, trimmed", () => {
+      const filters: Array<TraceRecordingRuleAttributeFilter> =
+        TraceRecordingRuleDefinitionUtil.getSourceAttributeFilters(
+          makeSource({
+            filterAttributes: [{ key: " http.route ", value: " /api " }],
+          }),
+        );
+
+      expect(filters).toEqual([{ key: "http.route", value: "/api" }]);
+    });
+
+    test("drops entries with a missing key or value, and deduplicates by key", () => {
+      const filters: Array<TraceRecordingRuleAttributeFilter> =
+        TraceRecordingRuleDefinitionUtil.getSourceAttributeFilters(
+          makeSource({
+            filterAttributes: [
+              { key: "host", value: "a" },
+              { key: "host", value: "b" }, // duplicate key — dropped
+              { key: "empty", value: "" }, // no value — dropped
+            ],
+          }),
+        );
+
+      expect(filters).toEqual([{ key: "host", value: "a" }]);
+    });
+
+    test("merges the legacy single filter when its key is not already present", () => {
+      const filters: Array<TraceRecordingRuleAttributeFilter> =
+        TraceRecordingRuleDefinitionUtil.getSourceAttributeFilters(
+          makeSource({
+            filterAttributes: [{ key: "host", value: "a" }],
+            filterAttributeKey: "env",
+            filterAttributeValue: "prod",
+          }),
+        );
+
+      expect(filters).toEqual([
+        { key: "host", value: "a" },
+        { key: "env", value: "prod" },
+      ]);
+    });
+
+    test("array entry wins over the legacy filter for the same key", () => {
+      const filters: Array<TraceRecordingRuleAttributeFilter> =
+        TraceRecordingRuleDefinitionUtil.getSourceAttributeFilters(
+          makeSource({
+            filterAttributes: [{ key: "env", value: "staging" }],
+            filterAttributeKey: "env",
+            filterAttributeValue: "prod",
+          }),
+        );
+
+      expect(filters).toEqual([{ key: "env", value: "staging" }]);
+    });
+  });
+
+  describe("getNextAlias", () => {
+    test("returns A when empty and the first free letter otherwise", () => {
+      expect(TraceRecordingRuleDefinitionUtil.getNextAlias(undefined)).toBe(
+        "A",
+      );
+      expect(
+        TraceRecordingRuleDefinitionUtil.getNextAlias([
+          makeSource({ alias: "A" }),
+          makeSource({ alias: "C" }),
+        ]),
+      ).toBe("B");
+    });
+  });
+
+  describe("getEmptyDefinition", () => {
+    test("returns a single Count source aliased A that validates", () => {
+      const def: TraceRecordingRuleDefinition =
+        TraceRecordingRuleDefinitionUtil.getEmptyDefinition();
+
+      expect(def.sources.length).toBe(1);
+      expect(def.sources[0]!.alias).toBe("A");
+      expect(def.sources[0]!.aggregationType).toBe(TraceAggregationType.Count);
+      expect(def.expression).toBe("A");
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError(def),
+      ).toBeNull();
+    });
+  });
+
+  describe("getValidationError", () => {
+    const validDefinition: () => TraceRecordingRuleDefinition =
+      (): TraceRecordingRuleDefinition => {
+        return {
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "B" })],
+          expression: "A / B * 100",
+        };
+      };
+
+    test("accepts a valid definition", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError(validDefinition()),
+      ).toBeNull();
+    });
+
+    test("requires a definition", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError(undefined),
+      ).toBe("Definition is required.");
+    });
+
+    test("requires at least one source", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [],
+          expression: "A",
+        }),
+      ).toBe("Add at least one source.");
+    });
+
+    test("rejects more than the maximum number of sources", () => {
+      const sources: Array<TraceRecordingRuleSource> = Array.from(
+        { length: TRACE_RECORDING_RULE_MAX_SOURCES + 1 },
+        (_unused: unknown, i: number) => {
+          return makeSource({ alias: "ABCDE"[i] as string });
+        },
+      );
+
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources,
+          expression: "A",
+        }),
+      ).toContain(`at most ${TRACE_RECORDING_RULE_MAX_SOURCES}`);
+    });
+
+    test("rejects an invalid alias", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "1" })],
+          expression: "A",
+        }),
+      ).toContain("single uppercase letter");
+    });
+
+    test("rejects duplicate aliases", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "A" })],
+          expression: "A",
+        }),
+      ).toContain("Duplicate alias");
+    });
+
+    test("requires an aggregation type", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [
+            {
+              alias: "A",
+            } as unknown as TraceRecordingRuleSource,
+          ],
+          expression: "A",
+        }),
+      ).toContain("Aggregation type is required");
+    });
+
+    test("requires both a legacy filter key and value, or neither", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A", filterAttributeValue: "prod" })],
+          expression: "A",
+        }),
+      ).toContain("needs both a key and a value");
+    });
+
+    test("rejects a non-array filterAttributes", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [
+            makeSource({
+              alias: "A",
+              filterAttributes:
+                "nope" as unknown as Array<TraceRecordingRuleAttributeFilter>,
+            }),
+          ],
+          expression: "A",
+        }),
+      ).toContain("Invalid attribute filters");
+    });
+
+    test("rejects a half-specified filter row", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [
+            makeSource({
+              alias: "A",
+              filterAttributes: [{ key: "host", value: "" }],
+            }),
+          ],
+          expression: "A",
+        }),
+      ).toContain("remove the row");
+    });
+
+    test("requires an expression", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "   ",
+        }),
+      ).toBe("Expression is required.");
+    });
+
+    test("rejects an over-length expression", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "A".repeat(
+            TRACE_RECORDING_RULE_MAX_EXPRESSION_LENGTH + 1,
+          ),
+        }),
+      ).toContain(
+        `${TRACE_RECORDING_RULE_MAX_EXPRESSION_LENGTH} characters or fewer`,
+      );
+    });
+
+    test("rejects an expression referencing an undefined alias", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "A + B",
+        }),
+      ).toContain("references alias 'B'");
+    });
+
+    test("rejects an expression that references no alias", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "5 + 10",
+        }),
+      ).toContain("must reference at least one source alias");
+    });
+
+    test("rejects an expression with characters outside the DSL grammar", () => {
+      expect(
+        TraceRecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "B" })],
+          expression: "A & B",
+        }),
+      ).toContain("may only contain");
+    });
+  });
+});

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

@@ -55,6 +55,23 @@ describe("Dropdown", () => {
     expect(await screen.findByText("2")).toBeInTheDocument();
   });
 
+  test("renders the menu portal above modal surfaces", async () => {
+    const { getByRole } = render(
+      <Dropdown onChange={() => {}} options={options} />,
+    );
+    const dropdown: HTMLElement = getByRole("combobox");
+
+    fireEvent.keyDown(dropdown, { key: "ArrowDown", code: "ArrowDown" });
+    await screen.findByText("1");
+
+    const menuPortal: HTMLElement | null = document.querySelector<HTMLElement>(
+      ".ou-select__menu-portal",
+    );
+
+    expect(menuPortal).toBeInTheDocument();
+    expect(menuPortal).toHaveStyle({ zIndex: "60" });
+  });
+
   test("renders placeholder", async () => {
     const { getByText } = render(
       <Dropdown

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

@@ -0,0 +1,130 @@
+import EntityDropdown from "../../../UI/Components/EntityDropdown/EntityDropdown";
+import {
+  DROPDOWN_MENU_Z_INDEX,
+  DropdownOption,
+} from "../../../UI/Components/Dropdown/Dropdown";
+import getJestMockFunction, { MockFunction } from "../../../Tests/MockType";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import React from "react";
+
+describe("EntityDropdown", () => {
+  const options: Array<DropdownOption> = [
+    { value: "members", label: "Members" },
+    { value: "admins", label: "Admins" },
+  ];
+  const originalInnerHeight: number = window.innerHeight;
+  const originalInnerWidth: number = window.innerWidth;
+
+  const setViewport: (width: number, height: number) => void = (
+    width: number,
+    height: number,
+  ): void => {
+    Object.defineProperty(window, "innerWidth", {
+      configurable: true,
+      value: width,
+    });
+    Object.defineProperty(window, "innerHeight", {
+      configurable: true,
+      value: height,
+    });
+  };
+
+  const makeRect: (
+    left: number,
+    top: number,
+    width: number,
+    height: number,
+  ) => DOMRect = (
+    left: number,
+    top: number,
+    width: number,
+    height: number,
+  ): DOMRect => {
+    return {
+      bottom: top + height,
+      height,
+      left,
+      right: left + width,
+      top,
+      width,
+      x: left,
+      y: top,
+      toJSON: (): Record<string, never> => {
+        return {};
+      },
+    } as DOMRect;
+  };
+
+  const openDropdownAt: (rect: DOMRect) => HTMLInputElement = (
+    rect: DOMRect,
+  ): HTMLInputElement => {
+    const input: HTMLInputElement = screen.getByRole("combobox", {
+      name: "Team",
+    }) as HTMLInputElement;
+    const control: HTMLElement | null =
+      input.parentElement?.parentElement || null;
+
+    if (!control) {
+      throw new Error("EntityDropdown control was not rendered.");
+    }
+
+    jest.spyOn(control, "getBoundingClientRect").mockReturnValue(rect);
+    fireEvent.focus(input);
+
+    return input;
+  };
+
+  afterEach(() => {
+    cleanup();
+    jest.restoreAllMocks();
+    setViewport(originalInnerWidth, originalInnerHeight);
+  });
+
+  test("positions its fixed menu below the control above modal surfaces", () => {
+    setViewport(1000, 800);
+    render(<EntityDropdown ariaLabel="Team" options={options} />);
+
+    openDropdownAt(makeRect(120, 200, 320, 40));
+
+    const menu: HTMLElement = screen.getByTestId("entity-dropdown-menu");
+
+    expect(menu.classList.contains("fixed")).toBe(true);
+    expect(menu.style.top).toBe("244px");
+    expect(menu.style.bottom).toBe("");
+    expect(menu.style.left).toBe("120px");
+    expect(menu.style.width).toBe("320px");
+    expect(menu.style.maxHeight).toBe("384px");
+    expect(menu.style.visibility).toBe("visible");
+    expect(menu.style.zIndex).toBe(String(DROPDOWN_MENU_Z_INDEX));
+  });
+
+  test("flips its menu above a control near the modal footer", () => {
+    setViewport(1000, 600);
+    render(<EntityDropdown ariaLabel="Team" options={options} />);
+
+    openDropdownAt(makeRect(120, 520, 320, 40));
+
+    const menu: HTMLElement = screen.getByTestId("entity-dropdown-menu");
+
+    expect(menu.style.top).toBe("");
+    expect(menu.style.bottom).toBe("84px");
+    expect(menu.style.maxHeight).toBe("384px");
+    expect(menu.style.visibility).toBe("visible");
+  });
+
+  test("selects an option from the fixed menu", () => {
+    const onChange: MockFunction = getJestMockFunction();
+    setViewport(1000, 800);
+    render(
+      <EntityDropdown ariaLabel="Team" onChange={onChange} options={options} />,
+    );
+
+    openDropdownAt(makeRect(120, 200, 320, 40));
+    fireEvent.click(screen.getByRole("option", { name: "Members" }));
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith("members");
+    expect(screen.queryByTestId("entity-dropdown-menu")).toBeNull();
+  });
+});