@oneuptime/common 13.0.3 → 13.0.5

package/Tests/Types/OnCallDutyPolicy/LayerUtilExhaustiveRotation.test.ts

@@ -761,7 +761,7 @@ describe("Edge cases", () => {
     }
   });
 
-  it("NOTE: current behavior - getEvents emits a trailing negative-length event when the window end lands exactly on a rotation boundary; getMultiLayerEvents filters it out", () => {
+  it("getEvents does not emit a trailing negative-length event when the window end lands exactly on a rotation boundary", () => {
     const cfg: Cfg = {
       name: "boundary",
       intervalType: EventInterval.Day,
@@ -781,12 +781,15 @@ describe("Edge cases", () => {
     });
     const last: CalendarEvent = raw[raw.length - 1]!;
     /*
-     * NOTE: current behavior - the final event is inverted (end 1s before start).
-     * This is an internal artifact; both production consumers go through
-     * getMultiLayerEvents, which removes it (see assertion below). Not a
-     * user-observable defect, so it is documented rather than reported.
+     * The final event used to be inverted (end 1s before start). getEvents is
+     * consumed directly (layer shift preview, calendar feed coverage
+     * envelope), so it must never emit one.
      */
-    expect(OneUptimeDate.isBefore(last.end, last.start)).toBe(true);
+    expect(OneUptimeDate.isAfter(last.end, last.start)).toBe(true);
+    expect(OneUptimeDate.isSame(last.end, calEnd)).toBe(true);
+    for (const e of raw) {
+      expect(OneUptimeDate.isAfter(e.end, e.start)).toBe(true);
+    }
 
     const multi: CalendarEvent[] = util.getMultiLayerEvents({
       layers: [layerOf(cfg)],

package/Tests/Types/Rules/RuleCriteriaFieldRegistry.test.ts

@@ -0,0 +1,276 @@
+import fs from "fs";
+import path from "path";
+import { describe, expect, test } from "@jest/globals";
+import RULE_CRITERIA_FIELDS_BY_MODEL, {
+  RULE_CRITERIA_FIELDS_BY_MODEL as NAMED_RULE_CRITERIA_FIELDS_BY_MODEL,
+  getRuleCriteriaFieldsForModel,
+} from "../../../Types/Rules/RuleCriteriaFieldRegistry";
+
+const DATABASE_MODELS_ROOT: string = path.join(
+  __dirname,
+  "../../../Models/DatabaseModels",
+);
+
+const MODEL_NAMES: Array<string> = Object.keys(RULE_CRITERIA_FIELDS_BY_MODEL);
+
+/*
+ * Fields that describe what a rule DOES rather than what it matches. None of
+ * them may ever become an allowlisted match predicate: a filter on
+ * "ownerUsers" would let an API caller make a rule match on its own action.
+ */
+const ACTION_OR_BOOKKEEPING_FIELDS: Array<string> = [
+  "_id",
+  "id",
+  "projectId",
+  "project",
+  "name",
+  "description",
+  "isEnabled",
+  "priority",
+  "order",
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "createdByUser",
+  "createdByUserId",
+  "deletedByUser",
+  "deletedByUserId",
+  "ownerUsers",
+  "ownerTeams",
+  "labelsToAdd",
+  "onCallDutyPolicies",
+  "criteria",
+];
+
+function readModelSource(modelName: string): string {
+  return fs.readFileSync(
+    path.join(DATABASE_MODELS_ROOT, `${modelName}.ts`),
+    "utf8",
+  );
+}
+
+describe("RULE_CRITERIA_FIELDS_BY_MODEL", () => {
+  test("the default export and the named export are the same object", () => {
+    expect(RULE_CRITERIA_FIELDS_BY_MODEL).toBe(
+      NAMED_RULE_CRITERIA_FIELDS_BY_MODEL,
+    );
+  });
+
+  test("registers a non-trivial number of rule models", () => {
+    expect(MODEL_NAMES.length).toBeGreaterThanOrEqual(70);
+  });
+
+  test("every registered name is a *Rule model name", () => {
+    for (const modelName of MODEL_NAMES) {
+      expect(modelName).toMatch(/^[A-Z][A-Za-z0-9]*Rule$/);
+    }
+  });
+
+  test.each(MODEL_NAMES)(
+    "%s has at least one criteria field",
+    (modelName: string) => {
+      const fields: ReadonlyArray<string> | undefined =
+        RULE_CRITERIA_FIELDS_BY_MODEL[modelName];
+
+      expect(Array.isArray(fields)).toBe(true);
+      expect(fields!.length).toBeGreaterThan(0);
+    },
+  );
+
+  test.each(MODEL_NAMES)(
+    "%s lists each field exactly once",
+    (modelName: string) => {
+      const fields: ReadonlyArray<string> =
+        RULE_CRITERIA_FIELDS_BY_MODEL[modelName]!;
+
+      expect(new Set(fields).size).toBe(fields.length);
+    },
+  );
+
+  test.each(MODEL_NAMES)(
+    "%s only lists camelCase identifiers",
+    (modelName: string) => {
+      for (const field of RULE_CRITERIA_FIELDS_BY_MODEL[modelName]!) {
+        expect(field).toMatch(/^[a-z][A-Za-z0-9]*$/);
+      }
+    },
+  );
+
+  test.each(MODEL_NAMES)(
+    "%s never allowlists an action or bookkeeping field as a match predicate",
+    (modelName: string) => {
+      for (const field of RULE_CRITERIA_FIELDS_BY_MODEL[modelName]!) {
+        expect(ACTION_OR_BOOKKEEPING_FIELDS).not.toContain(field);
+      }
+    },
+  );
+
+  test.each(MODEL_NAMES)(
+    "%s names a database model that declares every registered field",
+    (modelName: string) => {
+      const modelPath: string = path.join(
+        DATABASE_MODELS_ROOT,
+        `${modelName}.ts`,
+      );
+
+      expect(fs.existsSync(modelPath)).toBe(true);
+
+      const source: string = readModelSource(modelName);
+
+      for (const field of RULE_CRITERIA_FIELDS_BY_MODEL[modelName]!) {
+        const declaration: RegExp = new RegExp(
+          `public\\s+${field}\\??\\s*[:=]`,
+        );
+
+        expect({
+          modelName,
+          field,
+          declared: declaration.test(source),
+        }).toEqual({ modelName, field, declared: true });
+      }
+    },
+  );
+
+  test("Label/Owner/OnCall/Privacy sibling rules for the same entity share one criteria contract", () => {
+    const siblingSuffixes: Array<string> = [
+      "LabelRule",
+      "OwnerRule",
+      "OnCallRule",
+      "PrivacyRule",
+      "GroupingRule",
+    ];
+    const groups: Map<string, Array<string>> = new Map<string, Array<string>>();
+
+    for (const modelName of MODEL_NAMES) {
+      const suffix: string | undefined = siblingSuffixes.find(
+        (candidate: string) => {
+          return modelName.endsWith(candidate);
+        },
+      );
+
+      if (!suffix) {
+        continue;
+      }
+
+      const entity: string = modelName.slice(0, -suffix.length);
+      const members: Array<string> = groups.get(entity) || [];
+      members.push(modelName);
+      groups.set(entity, members);
+    }
+
+    let comparedGroups: number = 0;
+
+    for (const [, members] of groups) {
+      if (members.length < 2) {
+        continue;
+      }
+
+      comparedGroups++;
+      const expected: ReadonlyArray<string> =
+        RULE_CRITERIA_FIELDS_BY_MODEL[members[0]!]!;
+
+      for (const member of members.slice(1)) {
+        expect({
+          member,
+          fields: RULE_CRITERIA_FIELDS_BY_MODEL[member],
+        }).toEqual({ member, fields: expected });
+      }
+    }
+
+    expect(comparedGroups).toBeGreaterThan(20);
+  });
+
+  test("alert rules match on alert severities and incident rules on incident severities, never the other way round", () => {
+    for (const modelName of MODEL_NAMES) {
+      const fields: ReadonlyArray<string> =
+        RULE_CRITERIA_FIELDS_BY_MODEL[modelName]!;
+
+      if (modelName.startsWith("Alert")) {
+        expect(fields).not.toContain("incidentSeverities");
+      }
+
+      if (modelName.startsWith("Incident")) {
+        expect(fields).not.toContain("alertSeverities");
+      }
+    }
+  });
+
+  test("AutoRemediationRule is the one rule that can match both incident and alert severities", () => {
+    const both: Array<string> = MODEL_NAMES.filter((modelName: string) => {
+      const fields: ReadonlyArray<string> =
+        RULE_CRITERIA_FIELDS_BY_MODEL[modelName]!;
+      return (
+        fields.includes("incidentSeverities") &&
+        fields.includes("alertSeverities")
+      );
+    });
+
+    expect(both).toEqual(["AutoRemediationRule"]);
+  });
+
+  test("pins a few representative contracts exactly", () => {
+    expect(RULE_CRITERIA_FIELDS_BY_MODEL["AlertReminderRule"]).toEqual([
+      "alertSeverities",
+      "labels",
+    ]);
+    expect(
+      RULE_CRITERIA_FIELDS_BY_MODEL["ScheduledMaintenanceReminderRule"],
+    ).toEqual(["labels"]);
+    expect(RULE_CRITERIA_FIELDS_BY_MODEL["NetworkSiteAssignmentRule"]).toEqual([
+      "subnetCidr",
+      "hostnamePattern",
+    ]);
+    expect(RULE_CRITERIA_FIELDS_BY_MODEL["RunbookRule"]).toEqual([
+      "titlePattern",
+      "descriptionPattern",
+    ]);
+    // IncidentSlaRule deliberately carries no monitor name/description patterns.
+    expect(RULE_CRITERIA_FIELDS_BY_MODEL["IncidentSlaRule"]).not.toContain(
+      "monitorNamePattern",
+    );
+  });
+});
+
+describe("getRuleCriteriaFieldsForModel", () => {
+  test.each(MODEL_NAMES)(
+    "returns the registered fields for %s",
+    (modelName: string) => {
+      expect(getRuleCriteriaFieldsForModel(modelName)).toBe(
+        RULE_CRITERIA_FIELDS_BY_MODEL[modelName],
+      );
+    },
+  );
+
+  test("returns undefined for a model that is not registered", () => {
+    expect(getRuleCriteriaFieldsForModel("Monitor")).toBeUndefined();
+    expect(getRuleCriteriaFieldsForModel("NotARealRule")).toBeUndefined();
+    expect(getRuleCriteriaFieldsForModel("")).toBeUndefined();
+  });
+
+  test("is case-sensitive: a near-miss spelling is not registered", () => {
+    expect(getRuleCriteriaFieldsForModel("alertlabelrule")).toBeUndefined();
+    expect(getRuleCriteriaFieldsForModel("ALERTLABELRULE")).toBeUndefined();
+    expect(getRuleCriteriaFieldsForModel(" AlertLabelRule")).toBeUndefined();
+  });
+
+  /*
+   * Regression: the lookup used a plain index, so inherited Object.prototype
+   * members answered with a function or object instead of undefined. A caller
+   * that treats "not undefined" as "registered" would then call .includes()
+   * on a function and throw a TypeError instead of rejecting the model.
+   */
+  test.each([
+    "constructor",
+    "toString",
+    "valueOf",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "__proto__",
+    "__defineGetter__",
+  ])(
+    "returns undefined for the inherited property name %s",
+    (modelName: string) => {
+      expect(getRuleCriteriaFieldsForModel(modelName)).toBeUndefined();
+    },
+  );
+});

package/Tests/Types/Rum/SessionReplayApiContracts.test.ts

@@ -8,6 +8,7 @@ import {
   SESSION_REPLAY_SORT_BY_VALUES,
   SessionReplayChunksRequestDto,
   SessionReplayExceptionSessionDto,
+  SessionReplayForExceptionRequestDto,
   SessionReplayForExceptionResponseDto,
   SessionReplayHeartbeatResponseDto,
   SessionReplayListFiltersDto,
@@ -38,10 +39,12 @@ import {
   readDtoStringMap,
   readDtoUnixMs,
 } from "../../../Types/Rum/SessionReplayApi";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
 import {
   SESSION_REPLAY_VISITOR_ID_PATTERN,
   SessionReplayChunkManifestEntry,
 } from "../../../Types/Rum/SessionReplay";
+import { JSONObject } from "../../../Types/JSON";
 
 /*
  * The DTOs are the wire between the Dashboard and TelemetryAPI's
@@ -256,6 +259,17 @@ describe("SessionReplayApi DTOs - today's wire shapes satisfy them", () => {
     expect(legacyHeartbeat.secondsWatched).toBe(30);
   });
 
+  it("a scoped /for-exception request carries both entity identifiers", () => {
+    const request: SessionReplayForExceptionRequestDto = {
+      fingerprint: "fp-1",
+      primaryEntityId: "service-1",
+      primaryEntityType: ServiceType.OpenTelemetry,
+    };
+
+    expect(request.primaryEntityId).toBe("service-1");
+    expect(request.primaryEntityType).toBe(ServiceType.OpenTelemetry);
+  });
+
   it("the additive list and manifest fields are all optional and carry the documented types", () => {
     const richItem: SessionReplayListItemDto = {
       ...legacyListItem,
@@ -431,6 +445,65 @@ describe("SessionReplayApi - the additive contracts the surfaces already ship",
     expect(neverIdentified.visitorId).toBe("");
   });
 
+  /*
+   * "Not finalized" is not "still recording". A closed tab's session stays
+   * unfinalized until the finalizer runs, so /list and /manifest now also
+   * say whether every tab of it has ended. Additive on both: an older
+   * server answers without it, and the Dashboard then falls back to
+   * reading "not finalized" as "recording", which is what it always did.
+   */
+  it("/list and /manifest: hasRecordingEnded is additive, and an older payload without it still parses", () => {
+    expect(legacyListItem.hasRecordingEnded).toBeUndefined();
+    expect(legacyHeader.hasRecordingEnded).toBeUndefined();
+
+    /* A payload exactly as an older server sends it, through the wire. */
+    const olderListWire: JSONObject = JSON.parse(
+      JSON.stringify({ ...legacyListItem, isFinalized: false }),
+    ) as JSONObject;
+    const olderHeaderWire: JSONObject = JSON.parse(
+      JSON.stringify({ ...legacyHeader, isFinalized: false }),
+    ) as JSONObject;
+
+    expect("hasRecordingEnded" in olderListWire).toBe(false);
+    expect("hasRecordingEnded" in olderHeaderWire).toBe(false);
+    /* The defensive reader turns "absent" into "not known to have ended". */
+    expect(readDtoBoolean(olderListWire, "hasRecordingEnded")).toBe(false);
+    expect(readDtoBoolean(olderHeaderWire, "hasRecordingEnded")).toBe(false);
+
+    const olderListItem: SessionReplayListItemDto =
+      olderListWire as unknown as SessionReplayListItemDto;
+    expect(olderListItem.isFinalized).toBe(false);
+    expect(olderListItem.hasRecordingEnded).toBeUndefined();
+
+    /* A current server: a closed tab's unfinalized session. */
+    const endedItem: SessionReplayListItemDto = {
+      ...legacyListItem,
+      isFinalized: false,
+      hasRecordingEnded: true,
+    };
+    const liveItem: SessionReplayListItemDto = {
+      ...legacyListItem,
+      isFinalized: false,
+      hasRecordingEnded: false,
+    };
+    const endedHeader: SessionReplayManifestHeaderDto = {
+      ...legacyHeader,
+      isFinalized: false,
+      hasRecordingEnded: true,
+    };
+
+    const endedWire: JSONObject = JSON.parse(
+      JSON.stringify(endedItem),
+    ) as JSONObject;
+    const endedHeaderWire: JSONObject = JSON.parse(
+      JSON.stringify(endedHeader),
+    ) as JSONObject;
+
+    expect(readDtoBoolean(endedWire, "hasRecordingEnded")).toBe(true);
+    expect(readDtoBoolean(endedHeaderWire, "hasRecordingEnded")).toBe(true);
+    expect(liveItem.hasRecordingEnded).toBe(false);
+  });
+
   /*
    * POST /telemetry/rum/session-replay/users: the list rolled up by
    * person. Its own route because a keyset page of sessions cannot be

package/Tests/Types/Rum/SessionReplayTransportContracts.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  SESSION_REPLAY_MOBILE_APP_IDENTIFIER_HEADER,
+  SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES,
+  SESSION_REPLAY_RECORDER_CAPABILITIES,
+  SESSION_REPLAY_RECORDER_KIND_HEADER,
+  SessionReplayFidelityNotice,
+  parseSessionReplayRecorderKindHeader,
+} from "../../../Types/Rum/SessionReplay";
+
+describe("session replay recorder transport contract", () => {
+  test("pins the public native request header names", () => {
+    expect(SESSION_REPLAY_RECORDER_KIND_HEADER).toBe(
+      "x-oneuptime-replay-recorder-kind",
+    );
+    expect(SESSION_REPLAY_MOBILE_APP_IDENTIFIER_HEADER).toBe(
+      "x-oneuptime-mobile-app-identifier",
+    );
+  });
+
+  test.each([undefined, null])(
+    "treats an absent recorder-kind header (%s) as the legacy DOM recorder",
+    (value: undefined | null) => {
+      expect(parseSessionReplayRecorderKindHeader(value)).toBe("dom");
+    },
+  );
+
+  test.each([
+    ["dom", "dom"],
+    ["rn-view-tree", "rn-view-tree"],
+  ])("accepts exact supported kind %s", (value: string, expected: string) => {
+    expect(parseSessionReplayRecorderKindHeader(value)).toBe(expected);
+  });
+
+  test.each([
+    "",
+    "DOM",
+    "RN-VIEW-TREE",
+    "rn_view_tree",
+    " rn-view-tree",
+    "rn-view-tree ",
+    "browser",
+    "mobile",
+  ])("rejects unknown or non-exact recorder kind %j", (value: string) => {
+    expect(parseSessionReplayRecorderKindHeader(value)).toBeNull();
+  });
+
+  test("rejects a repeated/non-scalar recorder-kind header", () => {
+    expect(
+      parseSessionReplayRecorderKindHeader(["rn-view-tree", "dom"]),
+    ).toBeNull();
+    expect(parseSessionReplayRecorderKindHeader({ value: "dom" })).toBeNull();
+  });
+
+  test("pins the capabilities emitted by the native recorder", () => {
+    expect(SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES).toEqual([
+      "mobile-view-tree",
+      "mobile-touch-events",
+      "custom-events",
+      "traits",
+      "tags",
+      "visibility",
+      "visitor-id",
+      "route-events",
+      "js-errors",
+    ]);
+    expect(new Set(SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES).size).toBe(
+      SESSION_REPLAY_MOBILE_RECORDER_CAPABILITIES.length,
+    );
+  });
+
+  test("keeps mobile-only capabilities out of the web recorder baseline", () => {
+    expect(SESSION_REPLAY_RECORDER_CAPABILITIES).not.toContain(
+      "mobile-view-tree",
+    );
+    expect(SESSION_REPLAY_RECORDER_CAPABILITIES).not.toContain(
+      "mobile-touch-events",
+    );
+  });
+
+  test("pins mobile fidelity disclosure codes as additive wire values", () => {
+    expect(SessionReplayFidelityNotice.MobileImagesOpaque).toBe(
+      "mobile-images-opaque",
+    );
+    expect(SessionReplayFidelityNotice.MobileWebViewOpaque).toBe(
+      "mobile-webview-opaque",
+    );
+    expect(SessionReplayFidelityNotice.MobileCanvasOpaque).toBe(
+      "mobile-canvas-opaque",
+    );
+    expect(SessionReplayFidelityNotice.MobileAnimationSampled).toBe(
+      "mobile-animation-sampled",
+    );
+  });
+});

package/Tests/Types/SecurityEvent/Connectors/ConnectorDiagnostics.test.ts

@@ -0,0 +1,82 @@
+import {
+  SecurityConnectorCheck,
+  SecurityConnectorCheckStatus,
+  summarizeCheckStatuses,
+} from "../../../../Types/SecurityEvent/Connectors/ConnectorDiagnostics";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The report verdict is folded from the checks. The rule is what the modal
+ * banner shows, so it is pinned: any failure fails the report, otherwise
+ * any warning makes it a warning, and skips are neutral (a skipped step is
+ * explained by the failure that caused it, never counted twice).
+ */
+
+function check(
+  status: SecurityConnectorCheckStatus,
+  key: string = status,
+): SecurityConnectorCheck {
+  return {
+    key,
+    name: key,
+    status,
+    durationMs: 1,
+    message: `${key} ${status}`,
+  };
+}
+
+describe("summarizeCheckStatuses", () => {
+  test("no checks is a pass (nothing failed, nothing warned)", () => {
+    expect(summarizeCheckStatuses([])).toBe("pass");
+  });
+
+  test("all passing checks pass", () => {
+    expect(summarizeCheckStatuses([check("pass"), check("pass")])).toBe("pass");
+  });
+
+  test("skips alone are neutral and leave the report passing", () => {
+    expect(summarizeCheckStatuses([check("skip")])).toBe("pass");
+    expect(summarizeCheckStatuses([check("pass"), check("skip")])).toBe("pass");
+  });
+
+  test("a single warning turns the report into a warning", () => {
+    expect(
+      summarizeCheckStatuses([check("pass"), check("warn"), check("skip")]),
+    ).toBe("warn");
+  });
+
+  test("a single failure wins over any number of passes and warnings", () => {
+    expect(
+      summarizeCheckStatuses([
+        check("pass"),
+        check("warn"),
+        check("fail"),
+        check("warn"),
+        check("skip"),
+      ]),
+    ).toBe("fail");
+  });
+
+  test("order does not matter", () => {
+    const statuses: Array<SecurityConnectorCheckStatus> = [
+      "warn",
+      "pass",
+      "fail",
+    ];
+
+    expect(
+      summarizeCheckStatuses(
+        statuses.map((status: SecurityConnectorCheckStatus) => {
+          return check(status);
+        }),
+      ),
+    ).toBe("fail");
+    expect(
+      summarizeCheckStatuses(
+        [...statuses].reverse().map((status: SecurityConnectorCheckStatus) => {
+          return check(status);
+        }),
+      ),
+    ).toBe("fail");
+  });
+});