@oneuptime/common 11.5.4 → 11.5.5

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

@@ -0,0 +1,274 @@
+import FixPerformanceTaskTrigger from "../../../Server/Utils/AI/SRE/FixPerformanceTaskTrigger";
+import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
+import { AnalyzableSpan } from "../../../Server/Utils/AI/PerfEvidence/SpanTreeAnalyzer";
+import CodeRepositoryService from "../../../Server/Services/CodeRepositoryService";
+import AIRunService from "../../../Server/Services/AIRunService";
+import AIRun from "../../../Models/DatabaseModels/AIRun";
+import AIRunType from "../../../Types/AI/AIRunType";
+import AIRunStatus from "../../../Types/AI/AIRunStatus";
+import CodeFixTaskType from "../../../Types/AI/CodeFixTaskType";
+import CodeFixTaskContext from "../../../Types/AI/CodeFixTaskContext";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * The FixPerformance trigger: the user clicks "Fix performance with AI" on
+ * the trace view, the SpanTreeAnalyzer must find a deterministic pattern in
+ * the trace's spans (the recipe's honesty gate — no finding, no task), a
+ * GitHub-App repository must exist for the PR, and at most one non-terminal
+ * FixPerformance run may exist per trace. Human-triggered, so no project
+ * opt-in flag; runs inside a user-facing endpoint, so every unmet gate must
+ * THROW a clear message, not swallow.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const traceId: string = "abc123trace";
+const userId: ObjectID = ObjectID.generate();
+
+function fakeRun(taskContext?: CodeFixTaskContext): AIRun {
+  return {
+    id: ObjectID.generate(),
+    taskContext,
+  } as unknown as AIRun;
+}
+
+// A trace with a textbook N+1: root + 5 near-identical children.
+function spansWithNPlusOne(): Array<AnalyzableSpan> {
+  const spans: Array<AnalyzableSpan> = [
+    {
+      spanId: "root",
+      name: "GET /orders",
+      startMs: 0,
+      endMs: 1000,
+    },
+  ];
+  for (let i: number = 0; i < 5; i++) {
+    spans.push({
+      spanId: `child-${i}`,
+      parentSpanId: "root",
+      name: `SELECT users ${i}`,
+      startMs: i * 100,
+      endMs: i * 100 + 100,
+      attributes: {
+        "db.statement": `SELECT * FROM users WHERE id = ${i}`,
+        "code.filepath": "src/orders/loader.ts",
+        "code.function": "loadUserForOrder",
+        "code.lineno": "42",
+      },
+    });
+  }
+  return spans;
+}
+
+// A healthy trace: no detector can fire.
+function healthySpans(): Array<AnalyzableSpan> {
+  return [
+    { spanId: "root", name: "GET /home", startMs: 0, endMs: 1000 },
+    { spanId: "a", parentSpanId: "root", name: "auth", startMs: 0, endMs: 500 },
+    {
+      spanId: "b",
+      parentSpanId: "root",
+      name: "render",
+      startMs: 500,
+      endMs: 1000,
+    },
+  ];
+}
+
+describe("FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace", () => {
+  beforeEach(() => {
+    // The daily fix-run budget has its own suite (FixRunBudget.test.ts).
+    jest.spyOn(FixRunBudget, "assertWithinBudget").mockResolvedValue();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("a traceId-less call is rejected before any query", async () => {
+    const countBy: jest.SpyInstance = jest.spyOn(
+      CodeRepositoryService,
+      "countBy",
+    );
+
+    await expect(
+      FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace({
+        projectId,
+        traceId: "",
+        spans: spansWithNPlusOne(),
+        userId,
+      }),
+    ).rejects.toThrow(BadDataException);
+
+    expect(countBy).not.toHaveBeenCalled();
+  });
+
+  test("a span-less trace is rejected before any query", async () => {
+    const countBy: jest.SpyInstance = jest.spyOn(
+      CodeRepositoryService,
+      "countBy",
+    );
+
+    await expect(
+      FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace({
+        projectId,
+        traceId,
+        spans: [],
+        userId,
+      }),
+    ).rejects.toThrow(/no spans/);
+
+    expect(countBy).not.toHaveBeenCalled();
+  });
+
+  test("no deterministic finding → reject with a clear message, nothing queried or enqueued", async () => {
+    const countBy: jest.SpyInstance = jest.spyOn(
+      CodeRepositoryService,
+      "countBy",
+    );
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace({
+        projectId,
+        traceId,
+        spans: healthySpans(),
+        userId,
+      }),
+    ).rejects.toThrow(/No deterministic performance pattern/);
+
+    expect(countBy).not.toHaveBeenCalled();
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("no GitHub-App repository → reject, nothing enqueued", async () => {
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(0));
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace({
+        projectId,
+        traceId,
+        spans: spansWithNPlusOne(),
+        userId,
+      }),
+    ).rejects.toThrow(/GitHub/);
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("dedupe: a live FixPerformance run for the SAME trace blocks a second one", async () => {
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    const findBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "findBy")
+      .mockResolvedValue([fakeRun({ traceId })]);
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace({
+        projectId,
+        traceId,
+        spans: spansWithNPlusOne(),
+        userId,
+      }),
+    ).rejects.toThrow(/already queued or running/);
+
+    // The dedupe scan is scoped to non-terminal FixPerformance runs.
+    expect(findBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: expect.objectContaining({
+          projectId: projectId,
+          runType: AIRunType.CodeFix,
+          codeFixTaskType: CodeFixTaskType.FixPerformance,
+        }),
+      }),
+    );
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("dedupe is per-trace: a live run for a DIFFERENT trace does not block", async () => {
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    jest
+      .spyOn(AIRunService, "findBy")
+      .mockResolvedValue([fakeRun({ traceId: "some-other-trace" })]);
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue(fakeRun());
+
+    await FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace({
+      projectId,
+      traceId,
+      spans: spansWithNPlusOne(),
+      userId,
+    });
+
+    expect(create).toHaveBeenCalledTimes(1);
+  });
+
+  test("happy path: enqueues a Queued FixPerformance run whose taskContext carries the evidence", async () => {
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    jest.spyOn(AIRunService, "findBy").mockResolvedValue([]);
+    const createdRun: AIRun = fakeRun();
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue(createdRun);
+
+    const run: AIRun =
+      await FixPerformanceTaskTrigger.createPerformanceFixTaskFromTrace({
+        projectId,
+        traceId,
+        spans: spansWithNPlusOne(),
+        serviceName: "orders-service",
+        userId,
+      });
+
+    expect(run).toBe(createdRun);
+
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          projectId: projectId,
+          runType: AIRunType.CodeFix,
+          codeFixTaskType: CodeFixTaskType.FixPerformance,
+          status: AIRunStatus.Queued,
+          // Attribution: the user who clicked the button.
+          userId: userId,
+          // No subject row — the evidence IS the context.
+          triggeredByIncidentId: undefined,
+          triggeredByAlertId: undefined,
+          taskContext: expect.objectContaining({
+            traceId: traceId,
+            serviceName: "orders-service",
+          }),
+        }),
+        props: expect.objectContaining({ isRoot: true }),
+      }),
+    );
+
+    // The stored findings are the deterministic N+1 evidence.
+    const storedContext: CodeFixTaskContext = (
+      create.mock.calls[0]![0] as { data: AIRun }
+    ).data.taskContext!;
+    expect(storedContext.performanceFindings).toHaveLength(1);
+    expect(storedContext.performanceFindings![0]!.spanCount).toBe(5);
+
+    // code.* attributes of implicated spans become resolver locations.
+    expect(storedContext.codeLocations).toEqual([
+      {
+        filePath: "src/orders/loader.ts",
+        functionName: "loadUserForOrder",
+        lineNumber: 42,
+      },
+    ]);
+  });
+});

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

@@ -0,0 +1,80 @@
+import GlobalConfig from "../../../Models/DatabaseModels/GlobalConfig";
+import GlobalConfigService from "../../../Server/Services/GlobalConfigService";
+import { OnUpdate } from "../../../Server/Types/Database/Hooks";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import logger from "../../../Server/Utils/Logger";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+type GlobalConfigServiceWithUpdateHook = {
+  onBeforeUpdate(
+    updateBy: UpdateBy<GlobalConfig>,
+  ): Promise<OnUpdate<GlobalConfig>>;
+};
+
+function makeUpdateBy(data: Record<string, unknown>): UpdateBy<GlobalConfig> {
+  return {
+    query: {},
+    data,
+    limit: 1,
+    skip: 0,
+    props: {
+      isRoot: true,
+    },
+  } as unknown as UpdateBy<GlobalConfig>;
+}
+
+describe("GlobalConfigService ClickHouse capacity settings", () => {
+  beforeEach(() => {
+    jest.spyOn(logger, "error").mockImplementation((): void => {
+      return undefined;
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("normalizes integer form strings before persisting", async () => {
+    jest.spyOn(GlobalConfigService, "findOneBy").mockResolvedValue({
+      clickhouseCapacityNotificationThresholdPercent: 80,
+      clickhouseDataPruningThresholdPercent: 90,
+      clickhouseDataPruningTargetPercent: 80,
+    } as GlobalConfig);
+
+    const result: OnUpdate<GlobalConfig> = await (
+      GlobalConfigService as unknown as GlobalConfigServiceWithUpdateHook
+    ).onBeforeUpdate(
+      makeUpdateBy({
+        clickhouseCapacityNotificationThresholdPercent: "85",
+        clickhouseDataPruningThresholdPercent: "95",
+        clickhouseDataPruningTargetPercent: "75",
+      }),
+    );
+
+    expect(
+      result.updateBy.data.clickhouseCapacityNotificationThresholdPercent,
+    ).toBe(85);
+    expect(result.updateBy.data.clickhouseDataPruningThresholdPercent).toBe(95);
+    expect(result.updateBy.data.clickhouseDataPruningTargetPercent).toBe(75);
+  });
+
+  test("rejects a normalized target that is not below the trigger", async () => {
+    jest.spyOn(GlobalConfigService, "findOneBy").mockResolvedValue({
+      clickhouseCapacityNotificationThresholdPercent: 80,
+      clickhouseDataPruningThresholdPercent: 90,
+      clickhouseDataPruningTargetPercent: 80,
+    } as GlobalConfig);
+
+    await expect(
+      (
+        GlobalConfigService as unknown as GlobalConfigServiceWithUpdateHook
+      ).onBeforeUpdate(
+        makeUpdateBy({
+          clickhouseDataPruningThresholdPercent: "85",
+          clickhouseDataPruningTargetPercent: "85",
+        }),
+      ),
+    ).rejects.toThrow(BadDataException);
+  });
+});

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

@@ -14,7 +14,7 @@ import { describe, expect, test, afterEach } from "@jest/globals";
  * and Slack/Teams ping (it sets isOwnerNotified itself, so the hook is its
  * only push channel).
  *
- * Callers that must NOT announce (Sentinel's RCA note, which has its own
+ * Callers that must NOT announce (the AI's RCA note, which has its own
  * quiet-mode-gated RootCause feed item) opt out explicitly with
  * props.ignoreHooks — see IncidentInvestigationRunner. These tests lock in
  * that the hook announces for both user-authored and user-less notes, so the

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

@@ -0,0 +1,313 @@
+import InstrumentationTaskTrigger from "../../../Server/Utils/AI/SRE/InstrumentationTaskTrigger";
+import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
+import ProjectService from "../../../Server/Services/ProjectService";
+import CodeRepositoryService from "../../../Server/Services/CodeRepositoryService";
+import AIRunService from "../../../Server/Services/AIRunService";
+import Project from "../../../Models/DatabaseModels/Project";
+import AIRun from "../../../Models/DatabaseModels/AIRun";
+import AIRunType from "../../../Types/AI/AIRunType";
+import AIRunStatus from "../../../Types/AI/AIRunStatus";
+import CodeFixTaskType from "../../../Types/AI/CodeFixTaskType";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * The ImproveInstrumentation trigger: an INCONCLUSIVE AI investigation
+ * enqueues a CodeFix AIRun that opens an instrumentation PR — but ONLY for
+ * projects that explicitly opted in (enableInstrumentationFixTasks, default
+ * FALSE — G11 posture), only when a GitHub-App repo exists to open the PR
+ * against, and at most one non-terminal run per incident/alert. The trigger
+ * runs inside postAnalysis, so it must NEVER throw.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const incidentId: ObjectID = ObjectID.generate();
+const alertId: ObjectID = ObjectID.generate();
+
+function fakeProject(data?: {
+  enableAi?: boolean;
+  enableInstrumentationFixTasks?: boolean;
+}): Project {
+  return {
+    id: projectId,
+    enableAi: data?.enableAi ?? true,
+    enableInstrumentationFixTasks: data?.enableInstrumentationFixTasks ?? true,
+  } as unknown as Project;
+}
+
+describe("InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask", () => {
+  test("does not enqueue when the project is missing", () => {
+    expect(
+      InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask({
+        project: null,
+        hasConnectedRepository: true,
+        existingRun: null,
+      }).enqueue,
+    ).toBe(false);
+  });
+
+  test("does not enqueue when AI is disabled for the project", () => {
+    expect(
+      InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask({
+        project: fakeProject({ enableAi: false }),
+        hasConnectedRepository: true,
+        existingRun: null,
+      }).enqueue,
+    ).toBe(false);
+  });
+
+  test("opt-in is strict: an unset flag (legacy row) never enqueues — default is FALSE", () => {
+    const project: Project = {
+      id: projectId,
+      enableAi: true,
+      // enableInstrumentationFixTasks deliberately absent.
+    } as unknown as Project;
+
+    const decision: ReturnType<
+      typeof InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask
+    > = InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask({
+      project,
+      hasConnectedRepository: true,
+      existingRun: null,
+    });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/not opted in/);
+  });
+
+  test("does not enqueue without a GitHub-App-connected repository", () => {
+    const decision: ReturnType<
+      typeof InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask
+    > = InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask({
+      project: fakeProject(),
+      hasConnectedRepository: false,
+      existingRun: null,
+    });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/repository/);
+  });
+
+  test("dedupe: an existing non-terminal run for the subject blocks a second one", () => {
+    const decision: ReturnType<
+      typeof InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask
+    > = InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask({
+      project: fakeProject(),
+      hasConnectedRepository: true,
+      existingRun: { id: ObjectID.generate() } as unknown as AIRun,
+    });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/already exists/);
+  });
+
+  test("enqueues when opted in, a repository exists, and no run is live for the subject", () => {
+    expect(
+      InstrumentationTaskTrigger.shouldEnqueueInstrumentationTask({
+        project: fakeProject(),
+        hasConnectedRepository: true,
+        existingRun: null,
+      }).enqueue,
+    ).toBe(true);
+  });
+});
+
+describe("InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation", () => {
+  beforeEach(() => {
+    /*
+     * The daily fix-run budget defaults to allowed; its own decision matrix
+     * lives in FixRunBudget.test.ts. Mocking getBudgetStatus covers both
+     * the trigger's pre-check and assertWithinBudget inside the enqueue.
+     */
+    jest.spyOn(FixRunBudget, "getBudgetStatus").mockResolvedValue({
+      allowed: true,
+      limit: 25,
+      paused: false,
+      runsToday: 0,
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("over the daily fix-run budget: a logged SKIP — no run created, nothing thrown into the investigation", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    jest.spyOn(FixRunBudget, "getBudgetStatus").mockResolvedValue({
+      allowed: false,
+      limit: 25,
+      paused: false,
+      runsToday: 25,
+    });
+    const countBy: jest.SpyInstance = jest.spyOn(
+      CodeRepositoryService,
+      "countBy",
+    );
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+        projectId,
+        incidentId,
+      }),
+    ).resolves.toBeUndefined();
+
+    // Skipped before the repo/dedupe queries, and no run was created.
+    expect(countBy).not.toHaveBeenCalled();
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("a not-opted-in project skips cheaply: no repo count, no dedupe query, no run created", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject({ enableInstrumentationFixTasks: false }));
+    const countBy: jest.SpyInstance = jest.spyOn(
+      CodeRepositoryService,
+      "countBy",
+    );
+    const findOneBy: jest.SpyInstance = jest.spyOn(AIRunService, "findOneBy");
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+      projectId,
+      incidentId,
+    });
+
+    expect(countBy).not.toHaveBeenCalled();
+    expect(findOneBy).not.toHaveBeenCalled();
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("records a Queued ImproveInstrumentation CodeFix run carrying the incident subject", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValue(null);
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue({ id: ObjectID.generate() } as unknown as AIRun);
+
+    await InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+      projectId,
+      incidentId,
+    });
+
+    // The dedupe guard queries per (subject, ImproveInstrumentation).
+    expect(findOneBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: expect.objectContaining({
+          runType: AIRunType.CodeFix,
+          codeFixTaskType: CodeFixTaskType.ImproveInstrumentation,
+          triggeredByIncidentId: incidentId,
+        }),
+      }),
+    );
+
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          projectId: projectId,
+          runType: AIRunType.CodeFix,
+          codeFixTaskType: CodeFixTaskType.ImproveInstrumentation,
+          status: AIRunStatus.Queued,
+          triggeredByIncidentId: incidentId,
+        }),
+        props: expect.objectContaining({ isRoot: true }),
+      }),
+    );
+  });
+
+  test("an alert-subject investigation enqueues with triggeredByAlertId", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue({ id: ObjectID.generate() } as unknown as AIRun);
+
+    await InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+      projectId,
+      alertId,
+    });
+
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          codeFixTaskType: CodeFixTaskType.ImproveInstrumentation,
+          triggeredByAlertId: alertId,
+        }),
+      }),
+    );
+  });
+
+  test("dedupe: a live ImproveInstrumentation run for the same subject blocks creation", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValue({ id: ObjectID.generate() } as unknown as AIRun);
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+      projectId,
+      incidentId,
+    });
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("no GitHub-App repository means no run", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(0));
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+      projectId,
+      incidentId,
+    });
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("never throws — a failed enqueue must not fail the investigation's postAnalysis", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+    jest
+      .spyOn(AIRunService, "create")
+      .mockRejectedValue(new Error("database is down"));
+
+    await expect(
+      InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+        projectId,
+        incidentId,
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  test("a subjectless call is a no-op", async () => {
+    const findProject: jest.SpyInstance = jest.spyOn(
+      ProjectService,
+      "findOneById",
+    );
+
+    await InstrumentationTaskTrigger.enqueueForInconclusiveInvestigation({
+      projectId,
+    });
+
+    expect(findProject).not.toHaveBeenCalled();
+  });
+});