@oneuptime/common 11.5.4 → 11.5.5

package/Tests/Server/Infrastructure/Queue.test.ts

@@ -0,0 +1,227 @@
+import Queue, { QueueName } from "../../../Server/Infrastructure/Queue";
+import { RepeatableJob } from "bullmq";
+
+jest.mock("../../../Server/Infrastructure/Redis", () => {
+  return {
+    __esModule: true,
+    default: {
+      getRedisOptions: jest.fn().mockReturnValue({}),
+    },
+  };
+});
+
+type MockBullQueue = {
+  getRepeatableJobs: jest.Mock;
+  removeRepeatableByKey: jest.Mock;
+  getJob: jest.Mock;
+  clean: jest.Mock;
+  add: jest.Mock;
+  client: Promise<{ on: jest.Mock }>;
+};
+
+/*
+ * Must be prefixed with "mock" — jest.mock() factories are hoisted and may not
+ * reference out-of-scope variables that aren't so named.
+ */
+const mockBullQueueInstances: Array<MockBullQueue> = [];
+
+jest.mock("bullmq", () => {
+  return {
+    __esModule: true,
+    Queue: jest.fn().mockImplementation(() => {
+      const instance: MockBullQueue = {
+        getRepeatableJobs: jest.fn().mockResolvedValue([]),
+        removeRepeatableByKey: jest.fn().mockResolvedValue(true),
+        getJob: jest.fn().mockResolvedValue(undefined),
+        clean: jest.fn().mockResolvedValue([]),
+        add: jest.fn().mockResolvedValue({}),
+        client: Promise.resolve({ on: jest.fn() }),
+      };
+      mockBullQueueInstances.push(instance);
+      return instance;
+    }),
+  };
+});
+
+/*
+ * Builds a RepeatableJob as BullMQ returns it: `key` is the opaque md5 zset
+ * member, and is the ONLY thing removeRepeatableByKey() accepts.
+ */
+const repeatable: (name: string, key: string) => RepeatableJob = (
+  name: string,
+  key: string,
+): RepeatableJob => {
+  return {
+    key: key,
+    name: name,
+    id: null,
+    endDate: null,
+    tz: null,
+    pattern: "*/15 * * * *",
+  };
+};
+
+describe("Queue.removeRepeatableByName", () => {
+  let queue: MockBullQueue;
+
+  beforeAll(() => {
+    // Force the (cached) BullQueue for the Worker queue to be constructed.
+    Queue.getQueue(QueueName.Worker);
+    queue = mockBullQueueInstances[0] as MockBullQueue;
+  });
+
+  beforeEach(() => {
+    queue.getRepeatableJobs.mockReset().mockResolvedValue([]);
+    queue.removeRepeatableByKey.mockReset().mockResolvedValue(true);
+  });
+
+  /*
+   * The whole point of the method: go from a job NAME to the opaque repeat KEY.
+   * A renamed cron (e.g. SentinelInsight:ScanForInsights ->
+   * AIInsight:ScanForInsights) leaves its old repeatable behind in Redis,
+   * firing forever, and the name is all we have to find it by.
+   */
+  it("removes a repeatable whose name matches, using its key", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("AIInsight:ScanForInsights", "aaaaaaaaaaaaaaaa"),
+      repeatable("SentinelInsight:ScanForInsights", "86b9a73a59ccbe97264b573"),
+    ]);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(1);
+    expect(queue.removeRepeatableByKey).toHaveBeenCalledTimes(1);
+    expect(queue.removeRepeatableByKey).toHaveBeenCalledWith(
+      "86b9a73a59ccbe97264b573",
+    );
+  });
+
+  /*
+   * Regression guard for the trap this method exists to avoid: BullMQ's
+   * removeRepeatableByKey() ZREMs the exact member it is given, so passing a
+   * job NAME (or a job id derived from it) matches nothing and silently
+   * no-ops. The key must be the one from getRepeatableJobs().
+   */
+  it("never passes the job name to removeRepeatableByKey", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("SentinelInsight:ScanForInsights", "86b9a73a59ccbe97264b573"),
+    ]);
+
+    await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(queue.removeRepeatableByKey).not.toHaveBeenCalledWith(
+      "SentinelInsight:ScanForInsights",
+    );
+    // ...nor the ":"-sanitized form that Queue.removeJob() would have used.
+    expect(queue.removeRepeatableByKey).not.toHaveBeenCalledWith(
+      "SentinelInsight-ScanForInsights",
+    );
+  });
+
+  it("removes every repeatable sharing the name and returns the count", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("SentinelInsight:ScanForInsights", "key-one"),
+      repeatable("SomeOther:Job", "key-two"),
+      repeatable("SentinelInsight:ScanForInsights", "key-three"),
+    ]);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(2);
+    expect(
+      queue.removeRepeatableByKey.mock.calls.map((c: Array<string>) => {
+        return c[0];
+      }),
+    ).toEqual(["key-one", "key-three"]);
+  });
+
+  /*
+   * Idempotence is what lets this run on EVERY worker boot: once the legacy
+   * repeatable is gone (or on a fresh install that never had it), the sweep
+   * must be a cheap no-op rather than an error.
+   */
+  it("is a no-op when no repeatable has that name", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("AIInsight:ScanForInsights", "aaaaaaaaaaaaaaaa"),
+    ]);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(0);
+    expect(queue.removeRepeatableByKey).not.toHaveBeenCalled();
+  });
+
+  it("does not count a repeatable BullMQ reported as not removed", async () => {
+    queue.getRepeatableJobs.mockResolvedValue([
+      repeatable("SentinelInsight:ScanForInsights", "key-one"),
+    ]);
+    // BullMQ returns false when the key was already gone from the repeat zset.
+    queue.removeRepeatableByKey.mockResolvedValue(false);
+
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "SentinelInsight:ScanForInsights",
+    );
+
+    expect(removedCount).toBe(0);
+  });
+
+  it("skips the Redis round trip when the name is empty", async () => {
+    const removedCount: number = await Queue.removeRepeatableByName(
+      QueueName.Worker,
+      "",
+    );
+
+    expect(removedCount).toBe(0);
+    expect(queue.getRepeatableJobs).not.toHaveBeenCalled();
+  });
+});
+
+describe("Queue.removeJob", () => {
+  let queue: MockBullQueue;
+
+  beforeAll(() => {
+    Queue.getQueue(QueueName.Worker);
+    queue = mockBullQueueInstances[0] as MockBullQueue;
+  });
+
+  beforeEach(() => {
+    queue.getJob.mockReset().mockResolvedValue(undefined);
+    queue.removeRepeatableByKey.mockReset().mockResolvedValue(true);
+  });
+
+  /*
+   * The repeat key is NOT a job id: it is either an md5 or a legacy
+   * "name:id:endDate:tz:pattern" string. Sanitizing ":" -> "-" (which the job
+   * id lookup must do, since BullMQ rejects colons in custom ids) would mangle
+   * the legacy form into a zset member that does not exist, and the removal
+   * would silently no-op. QueueWorkflow passes job.repeatJobKey straight in
+   * here, so the raw value has to survive.
+   */
+  it("passes the repeat key through unsanitized", async () => {
+    await Queue.removeJob(QueueName.Worker, "myjob:someid:0::*/5 * * * *");
+
+    expect(queue.removeRepeatableByKey).toHaveBeenCalledWith(
+      "myjob:someid:0::*/5 * * * *",
+    );
+  });
+
+  // The job-id lookup, by contrast, must use the sanitized id.
+  it("looks the one-off job up by its sanitized id", async () => {
+    await Queue.removeJob(QueueName.Worker, "myjob:someid");
+
+    expect(queue.getJob).toHaveBeenCalledWith("myjob-someid");
+  });
+});

package/Tests/Server/Infrastructure/SemaphorePermit.test.ts

@@ -0,0 +1,159 @@
+import Redis, { ClientType } from "../../../Server/Infrastructure/Redis";
+import Semaphore, {
+  SemaphorePermit,
+} from "../../../Server/Infrastructure/Semaphore";
+import { Semaphore as RedisSemaphore } from "redis-semaphore";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+interface MockPermit {
+  acquire: jest.Mock;
+  release: jest.Mock;
+}
+
+jest.mock("redis-semaphore", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "redis-semaphore",
+  ) as Record<string, unknown>;
+
+  return {
+    ...actual,
+    Semaphore: jest.fn().mockImplementation((): MockPermit => {
+      return {
+        acquire: jest.fn(async (): Promise<void> => {}),
+        release: jest.fn(async (): Promise<void> => {}),
+      };
+    }),
+  };
+});
+
+const redisSemaphoreConstructor: jest.MockedClass<typeof RedisSemaphore> =
+  RedisSemaphore as jest.MockedClass<typeof RedisSemaphore>;
+
+function mockRedisClient(): ClientType {
+  const client: ClientType = {} as ClientType;
+  jest.spyOn(Redis, "getClient").mockReturnValue(client);
+  return client;
+}
+
+function lastMockPermit(): MockPermit {
+  const result: unknown = redisSemaphoreConstructor.mock.results.at(-1)?.value;
+  return result as MockPermit;
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  redisSemaphoreConstructor.mockClear();
+});
+
+describe("Semaphore distributed permits", () => {
+  test("constructs and acquires a fixed-size project pool with all options", async () => {
+    const client: ClientType = mockRedisClient();
+
+    const permit: SemaphorePermit = await Semaphore.acquirePermit({
+      key: "project-1",
+      namespace: "workflow-ai",
+      limit: 3,
+      lockTimeout: 65_000,
+      acquireTimeout: 250,
+      acquireAttemptsLimit: 1,
+      retryInterval: 50,
+    });
+
+    expect(redisSemaphoreConstructor).toHaveBeenCalledWith(
+      client,
+      "workflow-ai-project-1",
+      3,
+      {
+        lockTimeout: 65_000,
+        acquireTimeout: 250,
+        acquireAttemptsLimit: 1,
+        retryInterval: 50,
+      },
+    );
+    expect(lastMockPermit().acquire).toHaveBeenCalledTimes(1);
+    expect(permit).toBe(lastMockPermit());
+  });
+
+  test("uses the existing five-second lock default when none is supplied", async () => {
+    mockRedisClient();
+
+    await Semaphore.acquirePermit({
+      key: "project-1",
+      namespace: "workflow-ai",
+      limit: 3,
+    });
+
+    expect(redisSemaphoreConstructor).toHaveBeenCalledWith(
+      expect.anything(),
+      "workflow-ai-project-1",
+      3,
+      { lockTimeout: 5_000 },
+    );
+  });
+
+  test.each([0, -1, 1.5])(
+    "rejects invalid permit limit %p",
+    async (limit: number) => {
+      const getClient: jest.SpyInstance = jest.spyOn(Redis, "getClient");
+
+      await expect(
+        Semaphore.acquirePermit({
+          key: "project-1",
+          namespace: "workflow-ai",
+          limit,
+        }),
+      ).rejects.toThrow(/positive integer/i);
+
+      expect(getClient).not.toHaveBeenCalled();
+      expect(redisSemaphoreConstructor).not.toHaveBeenCalled();
+    },
+  );
+
+  test("rejects when Redis is not connected", async () => {
+    jest.spyOn(Redis, "getClient").mockReturnValue(null);
+
+    await expect(
+      Semaphore.acquirePermit({
+        key: "project-1",
+        namespace: "workflow-ai",
+        limit: 3,
+      }),
+    ).rejects.toThrow(/Redis client is not connected/i);
+
+    expect(redisSemaphoreConstructor).not.toHaveBeenCalled();
+  });
+
+  test("propagates acquisition failures without returning an unheld permit", async () => {
+    mockRedisClient();
+    const acquireError: Error = new Error("pool is full");
+    redisSemaphoreConstructor.mockImplementationOnce(() => {
+      return {
+        acquire: jest.fn(async (): Promise<void> => {
+          throw acquireError;
+        }),
+        release: jest.fn(async (): Promise<void> => {}),
+      } as unknown as RedisSemaphore;
+    });
+
+    await expect(
+      Semaphore.acquirePermit({
+        key: "project-1",
+        namespace: "workflow-ai",
+        limit: 3,
+      }),
+    ).rejects.toBe(acquireError);
+  });
+
+  test("releases the exact acquired permit", async () => {
+    mockRedisClient();
+    const permit: SemaphorePermit = await Semaphore.acquirePermit({
+      key: "project-1",
+      namespace: "workflow-ai",
+      limit: 3,
+    });
+
+    await Semaphore.releasePermit(permit);
+
+    expect(lastMockPermit().release).toHaveBeenCalledTimes(1);
+  });
+});

package/Tests/Server/Services/AIAgentTaskPullRequestOutcomeStats.test.ts

@@ -0,0 +1,154 @@
+import AIAgentTaskPullRequestService, {
+  AIFixOutcomeStats,
+} from "../../../Server/Services/AIAgentTaskPullRequestService";
+import PullRequestState from "../../../Types/CodeRepository/PullRequestState";
+import FixPullRequestCiStatus from "../../../Types/AI/FixPullRequestCiStatus";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import Query from "../../../Server/Types/Database/Query";
+import AIAgentTaskPullRequest from "../../../Models/DatabaseModels/AIAgentTaskPullRequest";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * The AI-fix acceptance rate (merged / terminal) is the G11 precision
+ * baseline. These tests lock the rate definition: open PRs are excluded
+ * from the denominator, and the rate is NULL (not 0 or 100) until at least
+ * one PR reached a terminal state. The B4 Tier 1 verified-green rate gets
+ * the same honesty rules: null only when NOTHING merged, and merged PRs
+ * whose CI never went green (or that have no CI at all) count AGAINST the
+ * rate — absence of CI is never presented as verified (G9).
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+
+function mockCounts(counts: {
+  open: number;
+  merged: number;
+  closed: number;
+  mergedCiGreen?: number;
+  mergedCiExpectedFailure?: number;
+}): void {
+  jest
+    .spyOn(AIAgentTaskPullRequestService, "countBy")
+    .mockImplementation((args: { query: Query<AIAgentTaskPullRequest> }) => {
+      const state: PullRequestState = args.query[
+        "pullRequestState"
+      ] as PullRequestState;
+      const ciStatus: FixPullRequestCiStatus | undefined = args.query[
+        "ciStatus"
+      ] as FixPullRequestCiStatus | undefined;
+
+      // The CI-filtered counts are always merged-scoped in the service.
+      if (ciStatus === FixPullRequestCiStatus.Green) {
+        expect(state).toBe(PullRequestState.Merged);
+        return Promise.resolve(new PositiveNumber(counts.mergedCiGreen || 0));
+      }
+
+      if (ciStatus === FixPullRequestCiStatus.ExpectedFailureObserved) {
+        expect(state).toBe(PullRequestState.Merged);
+        return Promise.resolve(
+          new PositiveNumber(counts.mergedCiExpectedFailure || 0),
+        );
+      }
+
+      const value: number =
+        state === PullRequestState.Open
+          ? counts.open
+          : state === PullRequestState.Merged
+            ? counts.merged
+            : counts.closed;
+
+      return Promise.resolve(new PositiveNumber(value));
+    });
+}
+
+describe("AIAgentTaskPullRequestService.getOutcomeStats", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("computes totals and acceptance rate from terminal outcomes only", async () => {
+    mockCounts({ open: 5, merged: 3, closed: 1 });
+
+    const stats: AIFixOutcomeStats =
+      await AIAgentTaskPullRequestService.getOutcomeStats({
+        isRoot: true,
+        tenantId: projectId,
+      });
+
+    expect(stats.total).toBe(9);
+    expect(stats.open).toBe(5);
+    expect(stats.merged).toBe(3);
+    expect(stats.closedUnmerged).toBe(1);
+    expect(stats.acceptanceRatePercent).toBe(75); // 3 / (3 + 1)
+  });
+
+  test("rate is null when no PR has reached a terminal state", async () => {
+    mockCounts({ open: 4, merged: 0, closed: 0 });
+
+    const stats: AIFixOutcomeStats =
+      await AIAgentTaskPullRequestService.getOutcomeStats({
+        isRoot: true,
+        tenantId: projectId,
+      });
+
+    expect(stats.total).toBe(4);
+    expect(stats.acceptanceRatePercent).toBeNull();
+  });
+
+  test("verified-green counts Green and ExpectedFailureObserved merges, over merged only", async () => {
+    mockCounts({
+      open: 1,
+      merged: 4,
+      closed: 2,
+      mergedCiGreen: 2,
+      mergedCiExpectedFailure: 1,
+    });
+
+    const stats: AIFixOutcomeStats =
+      await AIAgentTaskPullRequestService.getOutcomeStats({
+        isRoot: true,
+        tenantId: projectId,
+      });
+
+    expect(stats.verifiedGreen).toBe(3);
+    expect(stats.verifiedGreenRatePercent).toBe(75); // 3 / 4 merged
+    // Denominators are independent: acceptance is over terminal PRs.
+    expect(stats.acceptanceRatePercent).toBe(67); // 4 / 6 terminal
+  });
+
+  test("merged PRs without a green CI conclusion drag the rate to 0 — not null (G9: no CI is never verified)", async () => {
+    mockCounts({ open: 0, merged: 3, closed: 0 });
+
+    const stats: AIFixOutcomeStats =
+      await AIAgentTaskPullRequestService.getOutcomeStats({
+        isRoot: true,
+        tenantId: projectId,
+      });
+
+    expect(stats.verifiedGreen).toBe(0);
+    expect(stats.verifiedGreenRatePercent).toBe(0);
+  });
+
+  test("verified-green rate is null only when nothing merged, even with closed PRs", async () => {
+    mockCounts({ open: 2, merged: 0, closed: 3 });
+
+    const stats: AIFixOutcomeStats =
+      await AIAgentTaskPullRequestService.getOutcomeStats({
+        isRoot: true,
+        tenantId: projectId,
+      });
+
+    expect(stats.verifiedGreen).toBe(0);
+    expect(stats.verifiedGreenRatePercent).toBeNull();
+    // The acceptance denominator (terminal) is populated — independent.
+    expect(stats.acceptanceRatePercent).toBe(0);
+  });
+
+  test("throws without a tenant", async () => {
+    await expect(
+      AIAgentTaskPullRequestService.getOutcomeStats({ isRoot: true }),
+    ).rejects.toThrow(BadDataException);
+  });
+});