@oneuptime/common 13.0.7 → 13.0.8

package/Tests/Server/Utils/Workspace/Slack/Messages/ScheduledMaintenance.test.ts

@@ -0,0 +1,247 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import DatabaseConfig from "../../../../../../Server/DatabaseConfig";
+import ScheduledMaintenanceService from "../../../../../../Server/Services/ScheduledMaintenanceService";
+import SlackActionType from "../../../../../../Server/Utils/Workspace/Slack/Actions/ActionTypes";
+import SlackScheduledMaintenanceMessages from "../../../../../../Server/Utils/Workspace/Slack/Messages/ScheduledMaintenance";
+import Hostname from "../../../../../../Types/API/Hostname";
+import Protocol from "../../../../../../Types/API/Protocol";
+import BadDataException from "../../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../../Types/ObjectID";
+import {
+  WorkspaceMessageBlock,
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+} from "../../../../../../Types/Workspace/WorkspaceMessagePayload";
+
+const getButtons: (
+  blocks: Array<WorkspaceMessageBlock>,
+) => Array<WorkspaceMessagePayloadButton> = (
+  blocks: Array<WorkspaceMessageBlock>,
+): Array<WorkspaceMessagePayloadButton> => {
+  return (blocks[1] as WorkspacePayloadButtons).buttons;
+};
+
+describe("SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const scheduledMaintenanceId: ObjectID = ObjectID.generate();
+
+  beforeEach(() => {
+    jest
+      .spyOn(DatabaseConfig, "getHost")
+      .mockResolvedValue(new Hostname("oneuptime.test"));
+    jest
+      .spyOn(DatabaseConfig, "getHttpProtocol")
+      .mockResolvedValue(Protocol.HTTPS);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("returns a divider followed by a single buttons block", async () => {
+    const blocks: Array<WorkspaceMessageBlock> =
+      await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      );
+
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ _type: "WorkspacePayloadDivider" });
+    expect(blocks[1]!._type).toBe("WorkspacePayloadButtons");
+  });
+
+  test("emits the 5 buttons in order with the expected action ids and titles", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    );
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.actionId;
+      }),
+    ).toEqual([
+      SlackActionType.ViewScheduledMaintenance,
+      SlackActionType.MarkScheduledMaintenanceAsOngoing,
+      SlackActionType.MarkScheduledMaintenanceAsComplete,
+      SlackActionType.ViewChangeScheduledMaintenanceState,
+      SlackActionType.ViewAddScheduledMaintenanceNote,
+    ]);
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.title;
+      }),
+    ).toEqual([
+      "🔗 View Event",
+      "⌛ Mark as Ongoing",
+      "✅ Mark as Completed",
+      "➡️ Change State",
+      "📄 Add Note",
+    ]);
+  });
+
+  test("every button carries the scheduled maintenance id as its value", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    );
+
+    expect(buttons).toHaveLength(5);
+
+    for (const button of buttons) {
+      expect(button._type).toBe("WorkspaceMessagePayloadButton");
+      expect(button.value).toBe(scheduledMaintenanceId.toString());
+      expect(button.value).not.toBe(projectId.toString());
+    }
+  });
+
+  test("only the view button links to the scheduled maintenance page in the dashboard", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    );
+
+    expect(buttons[0]!.url?.toString()).toBe(
+      `https://oneuptime.test/dashboard/${projectId.toString()}/scheduled-maintenance-events/${scheduledMaintenanceId.toString()}`,
+    );
+
+    for (const button of buttons.slice(1)) {
+      expect(button.url).toBeUndefined();
+    }
+  });
+
+  test("asks ScheduledMaintenanceService for the link with the project and scheduled maintenance ids", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard
+    > = jest.spyOn(
+      ScheduledMaintenanceService,
+      "getScheduledMaintenanceLinkInDashboard",
+    );
+
+    await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+      {
+        scheduledMaintenanceId,
+        projectId,
+      },
+    );
+
+    expect(linkSpy).toHaveBeenCalledTimes(1);
+    expect(linkSpy).toHaveBeenCalledWith(projectId, scheduledMaintenanceId);
+  });
+
+  test("throws BadDataException when the scheduled maintenance id is missing", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard
+    > = jest.spyOn(
+      ScheduledMaintenanceService,
+      "getScheduledMaintenanceLinkInDashboard",
+    );
+
+    await expect(
+      SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId: undefined as unknown as ObjectID,
+          projectId,
+        },
+      ),
+    ).rejects.toThrow(
+      new BadDataException("ScheduledMaintenance ID is required"),
+    );
+
+    expect(linkSpy).not.toHaveBeenCalled();
+  });
+
+  test("throws BadDataException when the project id is missing", async () => {
+    await expect(
+      SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId: undefined as unknown as ObjectID,
+        },
+      ),
+    ).rejects.toThrow(new BadDataException("projectId is required"));
+  });
+
+  test("propagates a failure while building the dashboard link", async () => {
+    jest
+      .spyOn(
+        ScheduledMaintenanceService,
+        "getScheduledMaintenanceLinkInDashboard",
+      )
+      .mockRejectedValue(new Error("dashboard url unavailable"));
+
+    await expect(
+      SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    ).rejects.toThrow("dashboard url unavailable");
+  });
+
+  test("builds a fresh block list for each scheduled maintenance", async () => {
+    const otherId: ObjectID = ObjectID.generate();
+
+    const first: Array<WorkspaceMessageBlock> =
+      await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      );
+    const second: Array<WorkspaceMessageBlock> =
+      await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId: otherId,
+          projectId,
+        },
+      );
+
+    expect(first).not.toBe(second);
+    expect(getButtons(first)[0]!.value).toBe(scheduledMaintenanceId.toString());
+    expect(getButtons(second)[0]!.value).toBe(otherId.toString());
+    expect(getButtons(second)[0]!.url?.toString()).toContain(
+      `/scheduled-maintenance-events/${otherId.toString()}`,
+    );
+  });
+
+  test("does not offer on-call execution or acknowledge buttons", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await SlackScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    );
+
+    const titles: Array<string> = buttons.map(
+      (button: WorkspaceMessagePayloadButton) => {
+        return button.title;
+      },
+    );
+
+    expect(titles).not.toContain("📞 Execute On Call");
+    expect(
+      titles.some((title: string) => {
+        return title.includes("Acknowledge");
+      }),
+    ).toBe(false);
+  });
+});

package/Tests/Types/AI/AIInsightEvidence.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, test } from "@jest/globals";
+import AIInsightEvidence, {
+  ExceptionInsightEvidence,
+  LatencyInsightEvidence,
+  LogSpikeInsightEvidence,
+  MetricDriftInsightEvidence,
+} from "../../../Types/AI/AIInsightEvidence";
+import AIInsightType from "../../../Types/AI/AIInsightType";
+import { PerformanceFindingType } from "../../../Types/AI/CodeFixTaskContext";
+
+/*
+ * AIInsightEvidence is the JSON persisted verbatim on AIInsight.evidence and
+ * rendered long after the raw ClickHouse signals have expired. It is a pure
+ * type module, so these tests pin the wire contract in the two ways that
+ * matter: every AIInsightType maps to exactly one evidence section (checked
+ * exhaustively by the compiler via Record<AIInsightType, ...>), and each
+ * section survives a JSON round trip with its real numbers intact.
+ */
+
+type EvidenceSection = keyof AIInsightEvidence;
+
+/*
+ * The compiler rejects this map if an AIInsightType is added without deciding
+ * which evidence section carries it, or if a section key is renamed.
+ */
+const SECTION_FOR_TYPE: Record<AIInsightType, EvidenceSection> = {
+  [AIInsightType.NewException]: "exception",
+  [AIInsightType.ExceptionSpike]: "exception",
+  [AIInsightType.ErrorLogSpike]: "logSpike",
+  [AIInsightType.TraceLatencyRegression]: "latency",
+  [AIInsightType.MetricDrift]: "metricDrift",
+};
+
+const ALL_SECTIONS: Array<EvidenceSection> = [
+  "exception",
+  "logSpike",
+  "latency",
+  "metricDrift",
+];
+
+const setSections: (evidence: AIInsightEvidence) => Array<string> = (
+  evidence: AIInsightEvidence,
+): Array<string> => {
+  return Object.keys(evidence).filter((key: string) => {
+    return evidence[key as EvidenceSection] !== undefined;
+  });
+};
+
+const roundTrip: (evidence: AIInsightEvidence) => AIInsightEvidence = (
+  evidence: AIInsightEvidence,
+): AIInsightEvidence => {
+  return JSON.parse(JSON.stringify(evidence)) as AIInsightEvidence;
+};
+
+const exceptionEvidence: ExceptionInsightEvidence = {
+  exceptionMessage: "Cannot read properties of undefined (reading 'id')",
+  exceptionType: "TypeError",
+  recentOccurrenceCount: 42,
+  baselineHourlyAverage: 1.5,
+  spikeMultiplier: 28,
+  totalOccurrenceCount: 1200,
+  distinctExceptionGroupCount: 3,
+  firstSeenAt: "2026-09-18T10:00:00.000Z",
+};
+
+const logSpikeEvidence: LogSpikeInsightEvidence = {
+  recentErrorCount: 900,
+  baselineHourlyAverage: 30,
+  spikeMultiplier: 30,
+  windowMinutes: 60,
+  topServices: [
+    { serviceName: "checkout", count: 700 },
+    { serviceName: "payments", count: 200 },
+  ],
+};
+
+const latencyEvidence: LatencyInsightEvidence = {
+  recentP99Ms: 2400,
+  baselineP99Ms: 300,
+  regressionMultiplier: 8,
+  operationName: "GET /orders",
+  sampleTraceId: "4bf92f3577b34da6a3ce929d0e0e4736",
+  performanceFindings: [
+    {
+      findingType: PerformanceFindingType.NPlusOneQuery,
+      headline: 'N+1: 27x "SELECT users" under "GET /orders"',
+      evidence: "27 sibling spans, 1900ms combined",
+      spanCount: 27,
+      combinedDurationMs: 1900,
+      traceDurationMs: 2400,
+      percentOfTrace: 79.2,
+      normalizedSpanName: "SELECT users",
+      parentSpanName: "GET /orders",
+      normalizedDbStatement: "SELECT * FROM users WHERE id = ?",
+      dbSystem: "postgresql",
+      implicatedSpans: [
+        { spanId: "00f067aa0ba902b7", name: "SELECT users", durationMs: 70 },
+      ],
+    },
+  ],
+  codeLocations: [
+    {
+      filePath: "src/orders/list.ts",
+      functionName: "listOrders",
+      lineNumber: 88,
+    },
+  ],
+};
+
+const metricDriftEvidence: MetricDriftInsightEvidence = {
+  metricName: "http.server.request.duration",
+  primaryEntityId: "7e6a3c1a-1111-4222-8333-944455556666",
+  recentWeekMean: 150,
+  priorWeekMean: 100,
+  relativeChangePercent: 50,
+  recentSampleCount: 10080,
+  priorSampleCount: 10080,
+};
+
+describe("AIInsightEvidence", () => {
+  test("every insight type maps to a known evidence section", () => {
+    for (const type of Object.values(AIInsightType)) {
+      expect(ALL_SECTIONS).toContain(SECTION_FOR_TYPE[type]);
+    }
+  });
+
+  test("every evidence section is used by at least one insight type", () => {
+    const used: Set<EvidenceSection> = new Set(Object.values(SECTION_FOR_TYPE));
+    expect([...used].sort()).toEqual([...ALL_SECTIONS].sort());
+  });
+
+  test("an empty evidence object is valid (all sections optional)", () => {
+    const evidence: AIInsightEvidence = {};
+    expect(setSections(evidence)).toEqual([]);
+    expect(roundTrip(evidence)).toEqual({});
+  });
+
+  test.each([
+    ["exception", { exception: exceptionEvidence }],
+    ["logSpike", { logSpike: logSpikeEvidence }],
+    ["latency", { latency: latencyEvidence }],
+    ["metricDrift", { metricDrift: metricDriftEvidence }],
+  ] as Array<[EvidenceSection, AIInsightEvidence]>)(
+    "%s evidence survives a JSON round trip with exactly one section set",
+    (section: EvidenceSection, evidence: AIInsightEvidence) => {
+      expect(setSections(evidence)).toEqual([section]);
+      const restored: AIInsightEvidence = roundTrip(evidence);
+      expect(restored).toEqual(evidence);
+      expect(setSections(restored)).toEqual([section]);
+    },
+  );
+
+  test("exception evidence fields are all optional", () => {
+    const minimal: ExceptionInsightEvidence = {};
+    expect(roundTrip({ exception: minimal })).toEqual({ exception: {} });
+  });
+
+  test("undefined optional fields are dropped by serialisation", () => {
+    const evidence: AIInsightEvidence = {
+      latency: {
+        recentP99Ms: 500,
+        baselineP99Ms: 100,
+        regressionMultiplier: 5,
+        operationName: undefined,
+        sampleTraceId: undefined,
+      },
+      exception: undefined,
+    };
+    const restored: AIInsightEvidence = roundTrip(evidence);
+    expect(Object.keys(restored)).toEqual(["latency"]);
+    expect(Object.keys(restored.latency!).sort()).toEqual([
+      "baselineP99Ms",
+      "recentP99Ms",
+      "regressionMultiplier",
+    ]);
+  });
+
+  test("the numeric fields keep their exact values through storage", () => {
+    const restored: AIInsightEvidence = roundTrip({
+      metricDrift: { ...metricDriftEvidence, relativeChangePercent: -12.345 },
+    });
+    expect(restored.metricDrift?.relativeChangePercent).toBe(-12.345);
+    expect(restored.metricDrift?.recentSampleCount).toBe(10080);
+  });
+
+  test("performance findings keep their enum discriminator as a string", () => {
+    const restored: AIInsightEvidence = roundTrip({ latency: latencyEvidence });
+    expect(restored.latency?.performanceFindings?.[0]?.findingType).toBe(
+      "NPlusOneQuery",
+    );
+    expect(restored.latency?.codeLocations?.[0]?.lineNumber).toBe(88);
+  });
+
+  test("log spike topServices preserves order", () => {
+    const restored: AIInsightEvidence = roundTrip({
+      logSpike: logSpikeEvidence,
+    });
+    expect(
+      restored.logSpike?.topServices.map(
+        (service: { serviceName: string; count: number }) => {
+          return service.serviceName;
+        },
+      ),
+    ).toEqual(["checkout", "payments"]);
+  });
+});

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

@@ -0,0 +1,144 @@
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import DatabaseCommonInteractionPropsUtil from "../../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
+import Exception from "../../../Types/Exception/Exception";
+import ExceptionCode from "../../../Types/Exception/ExceptionCode";
+import NotAuthenticatedException from "../../../Types/Exception/NotAuthenticatedException";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
+import ObjectID from "../../../Types/ObjectID";
+import UserType from "../../../Types/UserType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * "No credentials at all" is the one refusal the browser client can recover
+ * from. The dashboard's access-token cookie expires with the 15-minute JWT
+ * inside it, so an idle tab's next request arrives with no user and no key,
+ * and the client refreshes the session and replays the request only when the
+ * answer is a 401. isAnonymous decides who is in that bucket and
+ * assertCredentialsPresent turns it into the 401; both are shared by
+ * CommonAPI, the AI privacy filters and ModelPermission, so a mistake here
+ * shows up as a bogus 422 (or a wrongly refreshed API key) everywhere at once.
+ */
+
+type PropsCase = [string, DatabaseCommonInteractionProps];
+
+const anonymousCases: Array<PropsCase> = [
+  ["no props at all", {}],
+  ["a tenant but no user", { tenantId: ObjectID.generate() }],
+  ["an explicitly Public caller", { userType: UserType.Public }],
+  [
+    "a Public caller with a tenant",
+    { tenantId: ObjectID.generate(), userType: UserType.Public },
+  ],
+  /*
+   * userType User without a userId cannot happen through getUserMiddleware,
+   * but if it did there is still nobody to scope to.
+   */
+  ["userType User but no userId", { userType: UserType.User }],
+];
+
+const credentialedCases: Array<PropsCase> = [
+  ["a signed-in user", { userId: ObjectID.generate() }],
+  [
+    "a signed-in user with userType User",
+    { userId: ObjectID.generate(), userType: UserType.User },
+  ],
+  /*
+   * A user id wins even over a Public userType: the caller named a user, so
+   * this is not an expired session.
+   */
+  [
+    "a user id with a Public userType",
+    { userId: ObjectID.generate(), userType: UserType.Public },
+  ],
+  // A project API key: credentials, but no user.
+  [
+    "a project API key",
+    { tenantId: ObjectID.generate(), userType: UserType.API },
+  ],
+  // A master API key / master-admin session with no userId on the props.
+  ["a master admin userType", { userType: UserType.MasterAdmin }],
+];
+
+describe("DatabaseCommonInteractionPropsUtil.AUTHENTICATION_REQUIRED_MESSAGE", () => {
+  test("is the shared login-required sentence", () => {
+    expect(
+      DatabaseCommonInteractionPropsUtil.AUTHENTICATION_REQUIRED_MESSAGE,
+    ).toBe("Authentication required. Please log in to access this resource.");
+  });
+});
+
+describe("DatabaseCommonInteractionPropsUtil.isAnonymous", () => {
+  test.each(anonymousCases)(
+    "is true for %s",
+    (_label: string, props: DatabaseCommonInteractionProps) => {
+      expect(DatabaseCommonInteractionPropsUtil.isAnonymous(props)).toBe(true);
+    },
+  );
+
+  test.each(credentialedCases)(
+    "is false for %s",
+    (_label: string, props: DatabaseCommonInteractionProps) => {
+      expect(DatabaseCommonInteractionPropsUtil.isAnonymous(props)).toBe(false);
+    },
+  );
+
+  /*
+   * isRoot / isMasterAdmin are NOT part of this question - callers that bypass
+   * permissions check those themselves before asking. Pinned so nobody folds
+   * them in and silently changes every caller's ordering.
+   */
+  test("does not look at isRoot or isMasterAdmin", () => {
+    expect(
+      DatabaseCommonInteractionPropsUtil.isAnonymous({ isRoot: true }),
+    ).toBe(true);
+    expect(
+      DatabaseCommonInteractionPropsUtil.isAnonymous({ isMasterAdmin: true }),
+    ).toBe(true);
+  });
+});
+
+describe("DatabaseCommonInteractionPropsUtil.assertCredentialsPresent", () => {
+  test.each(anonymousCases)(
+    "throws a 401 NotAuthenticatedException for %s",
+    (_label: string, props: DatabaseCommonInteractionProps) => {
+      let thrown: unknown = undefined;
+
+      try {
+        DatabaseCommonInteractionPropsUtil.assertCredentialsPresent(props);
+      } catch (error) {
+        thrown = error;
+      }
+
+      expect(thrown).toBeInstanceOf(NotAuthenticatedException);
+      expect(thrown).not.toBeInstanceOf(NotAuthorizedException);
+      expect((thrown as Exception).code).toBe(
+        ExceptionCode.NotAuthenticatedException,
+      );
+      expect((thrown as Exception).code).toBe(401);
+      expect((thrown as Exception).message).toBe(
+        DatabaseCommonInteractionPropsUtil.AUTHENTICATION_REQUIRED_MESSAGE,
+      );
+    },
+  );
+
+  test.each(credentialedCases)(
+    "does not throw for %s",
+    (_label: string, props: DatabaseCommonInteractionProps) => {
+      expect(() => {
+        DatabaseCommonInteractionPropsUtil.assertCredentialsPresent(props);
+      }).not.toThrow();
+    },
+  );
+
+  test("does not mutate the props it is given", () => {
+    const props: DatabaseCommonInteractionProps = {
+      tenantId: ObjectID.generate(),
+      userType: UserType.API,
+    };
+    const before: string = JSON.stringify(props);
+
+    DatabaseCommonInteractionPropsUtil.assertCredentialsPresent(props);
+
+    expect(JSON.stringify(props)).toBe(before);
+  });
+});