@oneuptime/common 11.5.3 → 11.5.5

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

@@ -0,0 +1,259 @@
+import AIService from "../../../Server/Services/AIService";
+import LlmLogService from "../../../Server/Services/LlmLogService";
+import LlmProviderService from "../../../Server/Services/LlmProviderService";
+import ProjectService, {
+  CurrentPlan,
+} from "../../../Server/Services/ProjectService";
+import LLMService from "../../../Server/Utils/LLM/LLMService";
+import LlmLog from "../../../Models/DatabaseModels/LlmLog";
+import LlmProvider from "../../../Models/DatabaseModels/LlmProvider";
+import Project from "../../../Models/DatabaseModels/Project";
+import SubscriptionPlan, {
+  PlanType,
+} from "../../../Types/Billing/SubscriptionPlan";
+import ExceptionCode from "../../../Types/Exception/ExceptionCode";
+import LlmType from "../../../Types/LLM/LlmType";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+type MockBillingGlobal = typeof globalThis & {
+  __oneuptimeAiServiceTestBillingEnabled: boolean;
+};
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../Server/EnvironmentConfig",
+  ) as Record<string, unknown>;
+  const mockedEnvironmentConfig: Record<string, unknown> = { ...actual };
+  const mockGlobal: MockBillingGlobal = globalThis as MockBillingGlobal;
+  mockGlobal.__oneuptimeAiServiceTestBillingEnabled = true;
+
+  Object.defineProperty(mockedEnvironmentConfig, "IsBillingEnabled", {
+    configurable: true,
+    enumerable: true,
+    get: (): boolean => {
+      return mockGlobal.__oneuptimeAiServiceTestBillingEnabled;
+    },
+  });
+
+  return mockedEnvironmentConfig;
+});
+
+const projectId: ObjectID = ObjectID.generate();
+
+function setMockIsBillingEnabled(value: boolean): void {
+  (globalThis as MockBillingGlobal).__oneuptimeAiServiceTestBillingEnabled =
+    value;
+}
+
+function fakeProject(enableAi: boolean = true): Project {
+  return {
+    id: projectId,
+    enableAi,
+  } as unknown as Project;
+}
+
+function mockProjectAndPlan(data: {
+  project: Project | null;
+  plan?: PlanType | null | undefined;
+  isSubscriptionUnpaid?: boolean | undefined;
+}): void {
+  jest.spyOn(ProjectService, "findOneById").mockResolvedValue(data.project);
+  jest.spyOn(ProjectService, "getCurrentPlan").mockResolvedValue({
+    plan: data.plan === undefined ? PlanType.Growth : data.plan,
+    isSubscriptionUnpaid: data.isSubscriptionUnpaid ?? false,
+  } as CurrentPlan);
+}
+
+describe("AIService.assertProjectCanUseAI", () => {
+  beforeEach(() => {
+    setMockIsBillingEnabled(true);
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    setMockIsBillingEnabled(true);
+  });
+
+  test("rejects when the project does not exist", async () => {
+    mockProjectAndPlan({ project: null });
+
+    await expect(
+      AIService.assertProjectCanUseAI(projectId),
+    ).rejects.toMatchObject({
+      code: ExceptionCode.BadDataException,
+      message: "Project not found.",
+    });
+  });
+
+  test("rejects when AI is disabled for the project", async () => {
+    mockProjectAndPlan({ project: fakeProject(false) });
+
+    await expect(
+      AIService.assertProjectCanUseAI(projectId),
+    ).rejects.toMatchObject({
+      code: ExceptionCode.BadDataException,
+      message: expect.stringContaining("AI features are disabled"),
+    });
+  });
+
+  test("rejects an unpaid cloud subscription before checking plan access", async () => {
+    mockProjectAndPlan({
+      project: fakeProject(),
+      plan: PlanType.Growth,
+      isSubscriptionUnpaid: true,
+    });
+    const planAccess: jest.SpiedFunction<
+      typeof SubscriptionPlan.isFeatureAccessibleOnCurrentPlan
+    > = jest.spyOn(SubscriptionPlan, "isFeatureAccessibleOnCurrentPlan");
+
+    await expect(
+      AIService.assertProjectCanUseAI(projectId),
+    ).rejects.toMatchObject({
+      code: ExceptionCode.PaymentRequiredException,
+      message: expect.stringContaining("subscription is unpaid"),
+    });
+    expect(planAccess).not.toHaveBeenCalled();
+  });
+
+  test("rejects a cloud plan below Growth", async () => {
+    mockProjectAndPlan({
+      project: fakeProject(),
+      plan: PlanType.Free,
+    });
+    const planAccess: jest.SpiedFunction<
+      typeof SubscriptionPlan.isFeatureAccessibleOnCurrentPlan
+    > = jest
+      .spyOn(SubscriptionPlan, "isFeatureAccessibleOnCurrentPlan")
+      .mockReturnValue(false);
+
+    await expect(
+      AIService.assertProjectCanUseAI(projectId),
+    ).rejects.toMatchObject({
+      code: ExceptionCode.PaymentRequiredException,
+      message: expect.stringContaining("upgrade your plan to Growth"),
+    });
+    expect(planAccess).toHaveBeenCalledWith(
+      PlanType.Growth,
+      PlanType.Free,
+      expect.any(Object),
+    );
+  });
+
+  test("permits an enabled project on a paid eligible cloud plan", async () => {
+    mockProjectAndPlan({
+      project: fakeProject(),
+      plan: PlanType.Enterprise,
+    });
+    const planAccess: jest.SpiedFunction<
+      typeof SubscriptionPlan.isFeatureAccessibleOnCurrentPlan
+    > = jest
+      .spyOn(SubscriptionPlan, "isFeatureAccessibleOnCurrentPlan")
+      .mockReturnValue(true);
+
+    await expect(
+      AIService.assertProjectCanUseAI(projectId),
+    ).resolves.toBeUndefined();
+    expect(planAccess).toHaveBeenCalledWith(
+      PlanType.Growth,
+      PlanType.Enterprise,
+      expect.any(Object),
+    );
+  });
+
+  test("permits an enabled self-hosted project without a subscription plan", async () => {
+    setMockIsBillingEnabled(false);
+    mockProjectAndPlan({
+      project: fakeProject(),
+      plan: null,
+    });
+    const planAccess: jest.SpiedFunction<
+      typeof SubscriptionPlan.isFeatureAccessibleOnCurrentPlan
+    > = jest.spyOn(SubscriptionPlan, "isFeatureAccessibleOnCurrentPlan");
+
+    await expect(
+      AIService.assertProjectCanUseAI(projectId),
+    ).resolves.toBeUndefined();
+    expect(planAccess).not.toHaveBeenCalled();
+  });
+});
+
+function mockFailedProviderRequest(
+  error: Error,
+): jest.SpiedFunction<typeof LlmLogService.create> {
+  jest.spyOn(LlmProviderService, "getProviderForChat").mockResolvedValue({
+    id: ObjectID.generate(),
+    name: "Test Provider",
+    llmType: LlmType.OpenAI,
+    modelName: "test-model",
+    isGlobalLlm: false,
+  } as unknown as LlmProvider);
+  jest.spyOn(LLMService, "getCompletion").mockRejectedValue(error);
+
+  return jest.spyOn(LlmLogService, "create").mockResolvedValue(new LlmLog());
+}
+
+describe("AIService.executeWithLogging error-detail storage", () => {
+  beforeEach(() => {
+    setMockIsBillingEnabled(true);
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    setMockIsBillingEnabled(true);
+  });
+
+  test("redacts provider details from both the thrown error and LLM log when disabled", async () => {
+    const privateProviderDetail: string =
+      "provider echoed private prompt value SECRET-123";
+    const createLog: jest.SpiedFunction<typeof LlmLogService.create> =
+      mockFailedProviderRequest(new Error(privateProviderDetail));
+    const safeMessage: string =
+      "The AI provider request failed. Review the provider configuration and try again.";
+
+    await expect(
+      AIService.executeWithLogging({
+        projectId,
+        feature: "AIService error-detail test",
+        messages: [{ role: "user", content: "harmless test request" }],
+        storeContentPreviews: false,
+        storeErrorDetails: false,
+      }),
+    ).rejects.toMatchObject({
+      code: ExceptionCode.BadDataException,
+      message: safeMessage,
+    });
+
+    expect(createLog).toHaveBeenCalledTimes(1);
+    expect(LLMService.getCompletion).toHaveBeenCalledWith(
+      expect.objectContaining({ includeProviderErrorDetails: false }),
+    );
+    const persistedLog: LlmLog = createLog.mock.calls[0]![0]!.data as LlmLog;
+    expect(persistedLog.statusMessage).toBe(safeMessage);
+    expect(JSON.stringify(persistedLog)).not.toContain(privateProviderDetail);
+  });
+
+  test("preserves raw provider error behavior by default", async () => {
+    const providerError: Error = new Error("raw provider failure detail");
+    const createLog: jest.SpiedFunction<typeof LlmLogService.create> =
+      mockFailedProviderRequest(providerError);
+
+    await expect(
+      AIService.executeWithLogging({
+        projectId,
+        feature: "AIService default error-detail test",
+        messages: [{ role: "user", content: "harmless test request" }],
+        storeContentPreviews: false,
+      }),
+    ).rejects.toBe(providerError);
+
+    expect(createLog).toHaveBeenCalledTimes(1);
+    expect(LLMService.getCompletion).toHaveBeenCalledWith(
+      expect.objectContaining({ includeProviderErrorDetails: true }),
+    );
+    const persistedLog: LlmLog = createLog.mock.calls[0]![0]!.data as LlmLog;
+    expect(persistedLog.statusMessage).toBe(providerError.message);
+  });
+});

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

@@ -0,0 +1,249 @@
+import FixFromIncidentTaskTrigger from "../../../Server/Utils/AI/SRE/FixFromIncidentTaskTrigger";
+import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
+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 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 FixFromIncident trigger: the user clicks "Open Fix PR from this
+ * analysis" on the investigation panel after a AI investigation
+ * completes, and the agent turns the posted analysis into a fix pull
+ * request. Human-triggered — so there is no project opt-in flag; the gates
+ * are: a COMPLETED investigation must exist for the subject (its analysis
+ * is the task's entire context), a GitHub-App repository must exist for the
+ * PR, and at most one non-terminal FixFromIncident run per subject.
+ * Unlike the ImproveInstrumentation sibling this runs inside a user-facing
+ * endpoint and must THROW clear messages, not swallow.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const incidentId: ObjectID = ObjectID.generate();
+const alertId: ObjectID = ObjectID.generate();
+const userId: ObjectID = ObjectID.generate();
+
+function fakeRun(): AIRun {
+  return { id: ObjectID.generate() } as unknown as AIRun;
+}
+
+describe("FixFromIncidentTaskTrigger.createFixTaskFromInvestigation", () => {
+  beforeEach(() => {
+    // The daily fix-run budget has its own suite (FixRunBudget.test.ts).
+    jest.spyOn(FixRunBudget, "assertWithinBudget").mockResolvedValue();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("a subjectless call is rejected before any query", async () => {
+    const findOneBy: jest.SpyInstance = jest.spyOn(AIRunService, "findOneBy");
+
+    await expect(
+      FixFromIncidentTaskTrigger.createFixTaskFromInvestigation({
+        projectId,
+        userId,
+      }),
+    ).rejects.toThrow(BadDataException);
+
+    expect(findOneBy).not.toHaveBeenCalled();
+  });
+
+  test("no completed investigation → reject with a clear message, nothing enqueued", async () => {
+    // The completed-investigation lookup is the first query.
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValue(null);
+    const countBy: jest.SpyInstance = jest.spyOn(
+      CodeRepositoryService,
+      "countBy",
+    );
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      FixFromIncidentTaskTrigger.createFixTaskFromInvestigation({
+        projectId,
+        incidentId,
+        userId,
+      }),
+    ).rejects.toThrow(/No completed AI investigation/);
+
+    expect(findOneBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: expect.objectContaining({
+          runType: AIRunType.Investigation,
+          status: AIRunStatus.Completed,
+          triggeredByIncidentId: incidentId,
+        }),
+      }),
+    );
+    expect(countBy).not.toHaveBeenCalled();
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("no GitHub-App repository → reject, nothing enqueued", async () => {
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(fakeRun());
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(0));
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      FixFromIncidentTaskTrigger.createFixTaskFromInvestigation({
+        projectId,
+        incidentId,
+        userId,
+      }),
+    ).rejects.toThrow(/GitHub/);
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("dedupe: a live FixFromIncident run for the same subject blocks a second one", async () => {
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      // 1st: the completed investigation exists.
+      .mockResolvedValueOnce(fakeRun())
+      // 2nd: a non-terminal FixFromIncident run already exists.
+      .mockResolvedValueOnce(fakeRun());
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      FixFromIncidentTaskTrigger.createFixTaskFromInvestigation({
+        projectId,
+        incidentId,
+        userId,
+      }),
+    ).rejects.toThrow(/already queued or running/);
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("over the daily fix-run budget: the user-facing call REJECTS with the budget message, nothing enqueued", async () => {
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(fakeRun()) // completed investigation
+      .mockResolvedValueOnce(null); // no duplicate run
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    jest
+      .spyOn(FixRunBudget, "assertWithinBudget")
+      .mockRejectedValue(
+        new BadDataException(
+          "The project's daily AI fix task limit has been reached",
+        ),
+      );
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      FixFromIncidentTaskTrigger.createFixTaskFromInvestigation({
+        projectId,
+        incidentId,
+        userId,
+      }),
+    ).rejects.toThrow(/daily AI fix task limit/);
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("happy path (incident): enqueues a Queued FixFromIncident run with user attribution", async () => {
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(fakeRun()) // completed investigation
+      .mockResolvedValueOnce(null); // no duplicate run
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    const createdRun: AIRun = fakeRun();
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue(createdRun);
+
+    const run: AIRun =
+      await FixFromIncidentTaskTrigger.createFixTaskFromInvestigation({
+        projectId,
+        incidentId,
+        userId,
+      });
+
+    expect(run).toBe(createdRun);
+
+    // The dedupe guard queries per (subject, FixFromIncident).
+    expect(findOneBy).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        query: expect.objectContaining({
+          runType: AIRunType.CodeFix,
+          codeFixTaskType: CodeFixTaskType.FixFromIncident,
+          triggeredByIncidentId: incidentId,
+        }),
+      }),
+    );
+
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          projectId: projectId,
+          runType: AIRunType.CodeFix,
+          codeFixTaskType: CodeFixTaskType.FixFromIncident,
+          status: AIRunStatus.Queued,
+          triggeredByIncidentId: incidentId,
+          // Attribution: the user who clicked the button.
+          userId: userId,
+        }),
+        props: expect.objectContaining({ isRoot: true }),
+      }),
+    );
+  });
+
+  test("happy path (alert): the run carries triggeredByAlertId", async () => {
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(fakeRun())
+      .mockResolvedValueOnce(null);
+    jest
+      .spyOn(CodeRepositoryService, "countBy")
+      .mockResolvedValue(new PositiveNumber(1));
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue(fakeRun());
+
+    await FixFromIncidentTaskTrigger.createFixTaskFromInvestigation({
+      projectId,
+      alertId,
+      userId,
+    });
+
+    // The completed-investigation gate keys on the alert subject.
+    expect(findOneBy).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        query: expect.objectContaining({
+          runType: AIRunType.Investigation,
+          status: AIRunStatus.Completed,
+          triggeredByAlertId: alertId,
+        }),
+      }),
+    );
+
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          codeFixTaskType: CodeFixTaskType.FixFromIncident,
+          triggeredByAlertId: alertId,
+          userId: userId,
+        }),
+      }),
+    );
+  });
+});