@oneuptime/common 11.5.8 → 11.5.10

package/Tests/Server/Utils/AI/ScheduledMaintenanceTools.test.ts

@@ -0,0 +1,176 @@
+import { QueryScheduledMaintenanceTool } from "../../../../Server/Utils/AI/Toolbox/ScheduledMaintenanceTools";
+import {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../Server/Utils/AI/Toolbox/ToolTypes";
+import ScheduledMaintenanceService from "../../../../Server/Services/ScheduledMaintenanceService";
+import ScheduledMaintenance from "../../../../Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenanceState from "../../../../Models/DatabaseModels/ScheduledMaintenanceState";
+import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import { AIChatCitationTargetType } from "../../../../Types/AI/AIChatTypes";
+import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * query_scheduled_maintenance closes the gap where "this maintenance event"
+ * had no fetch tool. These tests lock in what the model relies on: the detail
+ * mode returns the window + affected monitors for one event, the list mode
+ * respects its clamps, empty results are honest (rowCount 0), and citations
+ * deep-link to the right dashboard page.
+ */
+
+const ctx: ToolContext = {
+  projectId: ObjectID.generate(),
+  props: { isRoot: true },
+};
+
+const EVENT_ID: ObjectID = ObjectID.generate();
+
+function buildEvent(data?: {
+  id?: ObjectID;
+  number?: number;
+  title?: string;
+  state?: string;
+  monitors?: Array<string>;
+}): ScheduledMaintenance {
+  const event: ScheduledMaintenance = new ScheduledMaintenance();
+  event._id = (data?.id ?? EVENT_ID).toString();
+  event.title = data?.title ?? "Database upgrade";
+  event.description = "Upgrading postgres to 17.";
+  event.scheduledMaintenanceNumber = data?.number ?? 7;
+  event.startsAt = new Date("2026-07-20T01:00:00Z");
+  event.endsAt = new Date("2026-07-20T03:00:00Z");
+
+  const state: ScheduledMaintenanceState = new ScheduledMaintenanceState();
+  state.name = data?.state ?? "Scheduled";
+  event.currentScheduledMaintenanceState = state;
+
+  event.monitors = (data?.monitors ?? ["Payments API"]).map(
+    (name: string): Monitor => {
+      const monitor: Monitor = new Monitor();
+      monitor.name = name;
+      return monitor;
+    },
+  );
+
+  return event;
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("query_scheduled_maintenance — detail mode", () => {
+  test("returns the event's window and affected monitors with a view citation", async () => {
+    jest
+      .spyOn(ScheduledMaintenanceService, "findOneById")
+      .mockResolvedValue(buildEvent() as never);
+
+    const result: ToolExecutionResult =
+      await QueryScheduledMaintenanceTool.execute(
+        { scheduledMaintenanceId: EVENT_ID.toString() },
+        ctx,
+      );
+
+    expect(result.rowCount).toBe(1);
+    expect(result.dataForLlm).toContain("Database upgrade");
+    expect(result.dataForLlm).toContain("Payments API");
+    expect(result.dataForLlm).toContain("2026-07-20");
+    expect(result.citationLabel).toBe("Scheduled maintenance #7");
+    expect(result.citationTarget).toEqual({
+      type: AIChatCitationTargetType.ScheduledMaintenanceView,
+      params: { scheduledMaintenanceId: EVENT_ID.toString() },
+    });
+    expect(result.widget).toBeDefined();
+  });
+
+  test("a missing event is honest: zero rows, no widget", async () => {
+    jest
+      .spyOn(ScheduledMaintenanceService, "findOneById")
+      .mockResolvedValue(null as never);
+
+    const result: ToolExecutionResult =
+      await QueryScheduledMaintenanceTool.execute(
+        { scheduledMaintenanceId: EVENT_ID.toString() },
+        ctx,
+      );
+
+    expect(result.rowCount).toBe(0);
+    expect(result.widget).toBeUndefined();
+  });
+});
+
+describe("query_scheduled_maintenance — list mode", () => {
+  test("lists events overlapping the window, most recent first", async () => {
+    const findBySpy: jest.SpyInstance = jest
+      .spyOn(ScheduledMaintenanceService, "findBy")
+      .mockResolvedValue([
+        buildEvent({ number: 7 }),
+        buildEvent({
+          id: ObjectID.generate(),
+          number: 8,
+          title: "CDN failover drill",
+          state: "Ongoing",
+          monitors: [],
+        }),
+      ] as never);
+
+    const result: ToolExecutionResult =
+      await QueryScheduledMaintenanceTool.execute({}, ctx);
+
+    expect(result.rowCount).toBe(2);
+    expect(result.dataForLlm).toContain("Database upgrade");
+    expect(result.dataForLlm).toContain("CDN failover drill");
+    expect(result.citationLabel).toBe(
+      "Scheduled maintenance, -30d/+30d (2 found)",
+    );
+    expect(result.citationTarget).toEqual({
+      type: AIChatCitationTargetType.ScheduledMaintenanceEvents,
+    });
+
+    // The query must run under the requesting user's props, never as root+.
+    const callArgs: JSONObject = findBySpy.mock.calls[0]?.[0] as JSONObject;
+    expect(callArgs["props"]).toBe(ctx.props);
+    expect(callArgs["limit"]).toBe(10);
+  });
+
+  test("clamps the window and limit arguments", async () => {
+    const findBySpy: jest.SpyInstance = jest
+      .spyOn(ScheduledMaintenanceService, "findBy")
+      .mockResolvedValue([] as never);
+
+    const result: ToolExecutionResult =
+      await QueryScheduledMaintenanceTool.execute(
+        { pastDays: 10000, upcomingDays: -5, limit: 999 },
+        ctx,
+      );
+
+    expect(result.citationLabel).toBe(
+      "Scheduled maintenance, -365d/+0d (0 found)",
+    );
+
+    const callArgs: JSONObject = findBySpy.mock.calls[0]?.[0] as JSONObject;
+    expect(callArgs["limit"]).toBe(25);
+  });
+
+  test("an empty window is honest: zero rows and no widget", async () => {
+    jest
+      .spyOn(ScheduledMaintenanceService, "findBy")
+      .mockResolvedValue([] as never);
+
+    const result: ToolExecutionResult =
+      await QueryScheduledMaintenanceTool.execute({}, ctx);
+
+    expect(result.rowCount).toBe(0);
+    expect(result.widget).toBeUndefined();
+  });
+});
+
+describe("query_scheduled_maintenance — permissions", () => {
+  test("required permissions derive from the model read ACL", () => {
+    expect(
+      QueryScheduledMaintenanceTool.requiredPermissions.length,
+    ).toBeGreaterThan(0);
+  });
+});

package/Tests/Server/Utils/AnalyticsDatabase/ClickhouseCapacity.test.ts

@@ -1,9 +1,14 @@
+import {
+  ClickhouseAppInstance,
+  ClickhouseClient,
+} from "../../../../Server/Infrastructure/ClickhouseDatabase";
 import {
   buildClickhousePruningPlan,
   ClickhouseDiskSnapshot,
   ClickhousePartitionCandidate,
   ClickhousePlannedPartition,
   ClickhousePruningPlan,
+  dropClickhousePartition,
 } from "../../../../Server/Utils/AnalyticsDatabase/ClickhouseCapacity";
 import "../../TestingUtils/Init";
 
@@ -156,3 +161,61 @@ describe("ClickHouse capacity pruning planner", () => {
     expect(plan.targetReachable).toBe(false);
   });
 });
+
+describe("dropClickhousePartition", () => {
+  const command: jest.Mock = jest.fn();
+
+  beforeEach(() => {
+    command.mockReset();
+    command.mockResolvedValue({});
+    jest.spyOn(ClickhouseAppInstance, "getDataSource").mockReturnValue({
+      command,
+    } as unknown as ClickhouseClient);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  /*
+   * A day of spans on a large instance far exceeds the server's default 50 GB
+   * drop guard, which rejects the drop with TABLE_SIZE_EXCEEDS_MAX_DROP_SIZE_LIMIT
+   * unless the statement lifts it. Without the SETTINGS clause capacity pruning
+   * cannot prune the tables it exists for.
+   */
+  test("lifts the server drop-size guard on the statement", async () => {
+    await dropClickhousePartition({
+      tableName: "SpanItemV3Local",
+      partitionId: "20260101",
+    });
+
+    expect(command).toHaveBeenCalledWith({
+      query:
+        "ALTER TABLE `oneuptime`.`SpanItemV3Local` ON CLUSTER 'oneuptime' " +
+        "DROP PARTITION ID '20260101' SETTINGS max_partition_size_to_drop = 0",
+    });
+  });
+
+  // Lifting the size guard must not widen WHAT is droppable.
+  test("refuses a table outside the pruning allowlist", async () => {
+    await expect(
+      dropClickhousePartition({
+        tableName: "AuditLogV2Local",
+        partitionId: "20260101",
+      }),
+    ).rejects.toThrow("ClickHouse table is not eligible for pruning");
+
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  test("refuses a partition id that is not a daily partition", async () => {
+    await expect(
+      dropClickhousePartition({
+        tableName: "SpanItemV3Local",
+        partitionId: "202601",
+      }),
+    ).rejects.toThrow("Invalid ClickHouse daily partition id");
+
+    expect(command).not.toHaveBeenCalled();
+  });
+});

package/Tests/Server/Utils/GitHubGetFileContent.test.ts

@@ -0,0 +1,197 @@
+import GitHubUtil, {
+  GitHubFileContent,
+} from "../../../Server/Utils/CodeRepository/GitHub/GitHub";
+import API from "../../../Utils/API";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * getFileContent reads one file over the GitHub Contents API with no clone —
+ * the primitive that makes reading code viable from a request-scoped caller
+ * (the chat toolbox has a 45s per-tool timeout a clone cannot fit).
+ *
+ * The subtle contract these lock in: GitHub returns `content: ""` for BOTH a
+ * legitimately empty 0-byte file AND a blob it refuses to inline (>1MB). Only
+ * the `encoding` field tells them apart ("base64" vs "none"). Keying off the
+ * empty string alone reports every empty file as "too large".
+ */
+
+const ARGS: {
+  installationId: string;
+  organizationName: string;
+  repositoryName: string;
+  branchName: string;
+  filePath: string;
+} = {
+  installationId: "12345",
+  organizationName: "acme",
+  repositoryName: "checkout",
+  branchName: "main",
+  filePath: "src/billing/charge.ts",
+};
+
+function mockContentsResponse(data: JSONObject): void {
+  jest
+    .spyOn(API, "get")
+    .mockResolvedValue(new HTTPResponse<JSONObject>(200, data, {}));
+}
+
+beforeEach(() => {
+  // Token minting is exercised elsewhere; keep these tests to the read path.
+  jest
+    .spyOn(GitHubUtil, "getInstallationAccessToken")
+    .mockResolvedValue({ token: "t", expiresAt: new Date() });
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("GitHubUtil.getFileContent", () => {
+  test("decodes a base64 file and counts its lines", async () => {
+    mockContentsResponse({
+      type: "file",
+      size: 12,
+      encoding: "base64",
+      content: Buffer.from("alpha\nbravo\n").toString("base64"),
+      html_url: "https://github.com/acme/checkout/blob/main/x.ts",
+    });
+
+    const file: GitHubFileContent | null =
+      await GitHubUtil.getFileContent(ARGS);
+
+    expect(file).not.toBeNull();
+    expect(file!.content).toBe("alpha\nbravo\n");
+    // A trailing newline must not invent a phantom third line.
+    expect(file!.totalLines).toBe(2);
+  });
+
+  test("strips the newlines GitHub embeds in the base64 payload", async () => {
+    const encoded: string = Buffer.from("hello world").toString("base64");
+
+    mockContentsResponse({
+      type: "file",
+      size: 11,
+      encoding: "base64",
+      // GitHub wraps base64 at 60 chars; a naive decode would corrupt it.
+      content: `${encoded.slice(0, 4)}\n${encoded.slice(4)}\n`,
+      html_url: "",
+    });
+
+    const file: GitHubFileContent | null =
+      await GitHubUtil.getFileContent(ARGS);
+
+    expect(file!.content).toBe("hello world");
+  });
+
+  test("an empty 0-byte file reads as empty, NOT as too large", async () => {
+    mockContentsResponse({
+      type: "file",
+      size: 0,
+      encoding: "base64",
+      content: "",
+      html_url: "",
+    });
+
+    const file: GitHubFileContent | null =
+      await GitHubUtil.getFileContent(ARGS);
+
+    expect(file).not.toBeNull();
+    expect(file!.content).toBe("");
+    expect(file!.totalLines).toBe(0);
+  });
+
+  test("a blob GitHub refuses to inline is reported as too large", async () => {
+    mockContentsResponse({
+      type: "file",
+      size: 3151774,
+      encoding: "none",
+      content: "",
+      html_url: "",
+    });
+
+    await expect(GitHubUtil.getFileContent(ARGS)).rejects.toThrow(
+      /too large for GitHub to return inline/,
+    );
+  });
+
+  test("a missing path returns null so the caller can self-correct", async () => {
+    jest
+      .spyOn(API, "get")
+      .mockResolvedValue(
+        new HTTPErrorResponse(404, { message: "Not Found" }, {}),
+      );
+
+    await expect(GitHubUtil.getFileContent(ARGS)).resolves.toBeNull();
+  });
+
+  test("a directory returns null rather than mojibake", async () => {
+    jest
+      .spyOn(API, "get")
+      .mockResolvedValue(
+        new HTTPResponse<JSONObject>(
+          200,
+          [{ type: "file", name: "a.ts" }] as unknown as JSONObject,
+          {},
+        ),
+      );
+
+    await expect(GitHubUtil.getFileContent(ARGS)).resolves.toBeNull();
+  });
+
+  test("a binary file returns null rather than wasting context", async () => {
+    mockContentsResponse({
+      type: "file",
+      size: 4,
+      encoding: "base64",
+      content: Buffer.from([0x89, 0x50, 0x00, 0x47]).toString("base64"),
+      html_url: "",
+    });
+
+    await expect(GitHubUtil.getFileContent(ARGS)).resolves.toBeNull();
+  });
+
+  test("a submodule/symlink entry returns null", async () => {
+    mockContentsResponse({
+      type: "submodule",
+      size: 0,
+      content: "",
+      html_url: "",
+    });
+
+    await expect(GitHubUtil.getFileContent(ARGS)).resolves.toBeNull();
+  });
+
+  test("path segments are encoded without destroying the separators", async () => {
+    const spy: jest.SpiedFunction<typeof API.get> = jest
+      .spyOn(API, "get")
+      .mockResolvedValue(
+        new HTTPResponse<JSONObject>(
+          200,
+          {
+            type: "file",
+            size: 1,
+            encoding: "base64",
+            content: Buffer.from("x").toString("base64"),
+            html_url: "",
+          },
+          {},
+        ),
+      );
+
+    await GitHubUtil.getFileContent({
+      ...ARGS,
+      filePath: "src/my folder/charge spec.ts",
+    });
+
+    const calledUrl: string = (
+      spy.mock.calls[0]![0] as { url: { toString: () => string } }
+    ).url.toString();
+
+    // Slashes stay slashes; spaces get encoded.
+    expect(calledUrl).toContain("/contents/src/my%20folder/charge%20spec.ts");
+    expect(calledUrl).not.toContain("%2F");
+  });
+});