@oneuptime/common 13.0.6 → 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"]);
+  });
+});