@oneuptime/common 11.4.0 → 11.4.1

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

@@ -0,0 +1,127 @@
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
+import AggregationIntervalUtil from "../../../Types/BaseDatabase/AggregationIntervalUtil";
+
+describe("AggregationIntervalUtil", () => {
+  const SECOND: number = 1000;
+  const HOUR: number = SECOND * 60 * 60;
+  const DAY: number = HOUR * 24;
+
+  const windowOf: (durationMs: number) => { startDate: Date; endDate: Date } = (
+    durationMs: number,
+  ): { startDate: Date; endDate: Date } => {
+    const startDate: Date = new Date(Date.UTC(2020, 0, 1, 0, 0, 0));
+    const endDate: Date = new Date(startDate.getTime() + durationMs);
+    return { startDate, endDate };
+  };
+
+  describe("getAggregationIntervalForWindow", () => {
+    const cases: Array<[string, number, AggregationInterval]> = [
+      ["2 hours -> Minute", 2 * HOUR, AggregationInterval.Minute],
+      [
+        "exactly 3 hours -> Minute (inclusive bound)",
+        3 * HOUR,
+        AggregationInterval.Minute,
+      ],
+      ["3 hours + 1ms -> Hour", 3 * HOUR + 1, AggregationInterval.Hour],
+      ["1 day -> Hour", DAY, AggregationInterval.Hour],
+      [
+        "exactly 7 days -> Hour (inclusive bound)",
+        7 * DAY,
+        AggregationInterval.Hour,
+      ],
+      ["7 days + 1ms -> Day", 7 * DAY + 1, AggregationInterval.Day],
+      ["14 days -> Day", 14 * DAY, AggregationInterval.Day],
+      [
+        "exactly 6 weeks -> Day (inclusive bound)",
+        42 * DAY,
+        AggregationInterval.Day,
+      ],
+      ["6 weeks + 1ms -> Week", 42 * DAY + 1, AggregationInterval.Week],
+      ["60 days -> Week", 60 * DAY, AggregationInterval.Week],
+      ["200 days -> Month", 200 * DAY, AggregationInterval.Month],
+      ["8 years -> Year", 8 * 365 * DAY, AggregationInterval.Year],
+    ];
+
+    test.each(cases)(
+      "%s",
+      (_label: string, durationMs: number, expected: AggregationInterval) => {
+        expect(
+          AggregationIntervalUtil.getAggregationIntervalForWindow(
+            windowOf(durationMs),
+          ),
+        ).toBe(expected);
+      },
+    );
+
+    test("returns the widest interval as the window grows", () => {
+      const order: Array<AggregationInterval> = [
+        AggregationInterval.Minute,
+        AggregationInterval.Hour,
+        AggregationInterval.Day,
+        AggregationInterval.Week,
+        AggregationInterval.Month,
+        AggregationInterval.Year,
+      ];
+      const durations: Array<number> = [
+        HOUR,
+        2 * DAY,
+        30 * DAY,
+        90 * DAY,
+        365 * DAY,
+        10 * 365 * DAY,
+      ];
+
+      const results: Array<AggregationInterval> = durations.map(
+        (d: number): AggregationInterval => {
+          return AggregationIntervalUtil.getAggregationIntervalForWindow(
+            windowOf(d),
+          );
+        },
+      );
+
+      // Each larger window is at least as wide an interval as the previous.
+      for (let i: number = 1; i < results.length; i++) {
+        expect(order.indexOf(results[i]!)).toBeGreaterThanOrEqual(
+          order.indexOf(results[i - 1]!),
+        );
+      }
+    });
+  });
+
+  describe("getAggregationIntervalMs", () => {
+    test.each([
+      [AggregationInterval.Minute, 1000 * 60],
+      [AggregationInterval.Hour, 1000 * 60 * 60],
+      [AggregationInterval.Day, 1000 * 60 * 60 * 24],
+      [AggregationInterval.Week, 1000 * 60 * 60 * 24 * 7],
+      [AggregationInterval.Month, 1000 * 60 * 60 * 24 * 30],
+      [AggregationInterval.Year, 1000 * 60 * 60 * 24 * 365],
+    ])(
+      "maps %s to its nominal width",
+      (interval: AggregationInterval, expectedMs: number) => {
+        expect(AggregationIntervalUtil.getAggregationIntervalMs(interval)).toBe(
+          expectedMs,
+        );
+      },
+    );
+
+    test("intervals are strictly increasing in width", () => {
+      const ordered: Array<AggregationInterval> = [
+        AggregationInterval.Minute,
+        AggregationInterval.Hour,
+        AggregationInterval.Day,
+        AggregationInterval.Week,
+        AggregationInterval.Month,
+        AggregationInterval.Year,
+      ];
+
+      for (let i: number = 1; i < ordered.length; i++) {
+        expect(
+          AggregationIntervalUtil.getAggregationIntervalMs(ordered[i]!),
+        ).toBeGreaterThan(
+          AggregationIntervalUtil.getAggregationIntervalMs(ordered[i - 1]!),
+        );
+      }
+    });
+  });
+});

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/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