@oneuptime/common 11.7.4 → 12.0.1

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

@@ -0,0 +1,293 @@
+import LlmProviderService from "../../../Server/Services/LlmProviderService";
+import LlmProvider from "../../../Models/DatabaseModels/LlmProvider";
+import ObjectID from "../../../Types/ObjectID";
+import Select from "../../../Server/Types/Database/Select";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * isProviderUsableByProject answers "may this project run against this
+ * provider id?" for callers that hold a caller-supplied id — today the
+ * runbook AI step's optional provider pin, whose id comes out of an
+ * unvalidated JSON column.
+ *
+ * The invariant: a project may use a global provider or one it owns, and
+ * nothing else. A provider carries an apiKey, so a yes here for another
+ * project's row would hand project A the use of project B's key.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const otherProjectId: ObjectID = ObjectID.generate();
+const providerId: ObjectID = ObjectID.generate();
+
+function fakeProvider(overrides: Partial<LlmProvider> = {}): LlmProvider {
+  return {
+    id: providerId,
+    ...overrides,
+  } as unknown as LlmProvider;
+}
+
+describe("LlmProviderService.isProviderUsableByProject", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("accepts a provider the project owns", async () => {
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValue(fakeProvider({ projectId, isGlobalLlm: false }));
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(true);
+  });
+
+  test("accepts a global provider, which is shared with every project", async () => {
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValue(fakeProvider({ isGlobalLlm: true }));
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(true);
+  });
+
+  test("rejects a provider owned by a different project", async () => {
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(
+      fakeProvider({
+        projectId: otherProjectId,
+        isGlobalLlm: false,
+      }),
+    );
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  test("rejects a provider that no longer exists", async () => {
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(null);
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  test("rejects a provider with no owner and no global flag", async () => {
+    /*
+     * A row that is neither global nor owned matches nobody. Treating an
+     * absent projectId as a match would make an orphaned row usable by every
+     * project at once.
+     */
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValue(fakeProvider({ isGlobalLlm: false }));
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  test("rejects a non-uuid id without ever touching the database", async () => {
+    /*
+     * _id is a uuid column: querying it with garbage is a Postgres cast
+     * error, not an empty result. The id arrives from an unvalidated JSON
+     * config, so the shape check has to happen before the query — otherwise
+     * a typo in a runbook surfaces as a driver error during an incident.
+     */
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest.spyOn(LlmProviderService, "findOneBy");
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: new ObjectID("not-a-uuid"),
+      }),
+    ).resolves.toBe(false);
+
+    expect(findSpy).not.toHaveBeenCalled();
+  });
+
+  test("rejects an empty id without touching the database", async () => {
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest.spyOn(LlmProviderService, "findOneBy");
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: new ObjectID(""),
+      }),
+    ).resolves.toBe(false);
+
+    expect(findSpy).not.toHaveBeenCalled();
+  });
+
+  test("never selects the apiKey — a yes/no must not load secrets", async () => {
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(fakeProvider({ projectId }));
+
+    await LlmProviderService.isProviderUsableByProject({
+      projectId,
+      llmProviderId: providerId,
+    });
+
+    const select: Select<LlmProvider> = findSpy.mock.calls[0]![0]!
+      .select as Select<LlmProvider>;
+    expect(select["apiKey"]).toBeUndefined();
+    expect(select["projectId"]).toBe(true);
+    expect(select["isGlobalLlm"]).toBe(true);
+  });
+
+  test("looks the provider up by id alone, so a global row is reachable", async () => {
+    /*
+     * Scoping the query by projectId would silently exclude global
+     * providers (their projectId is NULL) — the tenant decision belongs in
+     * the check on the loaded row, not in the query.
+     */
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(fakeProvider({ isGlobalLlm: true }));
+
+    await LlmProviderService.isProviderUsableByProject({
+      projectId,
+      llmProviderId: providerId,
+    });
+
+    const query: Record<string, unknown> = findSpy.mock.calls[0]![0]!
+      .query as Record<string, unknown>;
+    expect(query["_id"]).toBe(providerId.toString());
+    expect(query["projectId"]).toBeUndefined();
+  });
+});
+
+/*
+ * getProviderForChat shares the same usability predicate. Its contract is the
+ * opposite of the runbook step's on failure — a human is watching a chat, so
+ * an unusable id falls back to the default instead of erroring — and these
+ * tests pin that difference down so a future refactor of the shared predicate
+ * cannot quietly swap one behaviour for the other.
+ */
+describe("LlmProviderService.getProviderForChat", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("uses an explicitly chosen provider the project owns", async () => {
+    const chosen: LlmProvider = fakeProvider({ projectId });
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(chosen);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      });
+
+    expect(result).toBe(chosen);
+    expect(findSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test("uses an explicitly chosen global provider", async () => {
+    const chosen: LlmProvider = fakeProvider({ isGlobalLlm: true });
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(chosen);
+
+    await expect(
+      LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(chosen);
+  });
+
+  test("falls back to the project default when the chosen provider belongs to another project", async () => {
+    const foreign: LlmProvider = fakeProvider({ projectId: otherProjectId });
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValueOnce(foreign)
+      .mockResolvedValueOnce(projectDefault);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      });
+
+    expect(result).toBe(projectDefault);
+  });
+
+  test("falls back when the chosen provider no longer exists", async () => {
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce(projectDefault);
+
+    await expect(
+      LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(projectDefault);
+  });
+
+  test("a non-uuid choice falls back instead of hitting the database with it", async () => {
+    /*
+     * Without the shape check this query is a Postgres cast error rather
+     * than a miss, so a stale or hand-edited id would break a whole
+     * conversation instead of quietly resolving to the default.
+     */
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(projectDefault);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: new ObjectID("not-a-uuid"),
+      });
+
+    expect(result).toBe(projectDefault);
+    // Only the default-resolution query ran — never one keyed on the garbage id.
+    for (const call of findSpy.mock.calls) {
+      expect(
+        (call[0]!.query as Record<string, unknown>)["_id"],
+      ).toBeUndefined();
+    }
+  });
+
+  test("with no choice at all it goes straight to default resolution", async () => {
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(projectDefault);
+
+    await expect(
+      LlmProviderService.getProviderForChat({ projectId }),
+    ).resolves.toBe(projectDefault);
+
+    const query: Record<string, unknown> = findSpy.mock.calls[0]![0]!
+      .query as Record<string, unknown>;
+    expect(query["isDefault"]).toBe(true);
+  });
+});

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

@@ -0,0 +1,145 @@
+import MonitorService from "../../../Server/Services/MonitorService";
+import MonitorStatusService from "../../../Server/Services/MonitorStatusService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import MonitorStepsProjectValidator from "../../../Server/Utils/Monitor/MonitorStepsProjectValidator";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorStatus from "../../../Models/DatabaseModels/MonitorStatus";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { PlanType } from "../../../Types/Billing/SubscriptionPlan";
+import ObjectID from "../../../Types/ObjectID";
+import FindOneBy from "../../../Server/Types/Database/FindOneBy";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * A monitor's initial currentMonitorStatusId is set in
+ * MonitorService.onBeforeCreate from the project's operational status. A
+ * project may hold MORE than one operational state (a user - or a Terraform
+ * fixture - can add another `isOperationalState: true` status), so this lookup
+ * must be DETERMINISTIC.
+ *
+ * Regression: the lookup carried no explicit sort, so findOneBy fell back to
+ * `createdAt DESC` and returned whichever operational status was created most
+ * recently. A monitor created right after a caller added a custom operational
+ * status silently adopted THAT status; when the custom status was later deleted
+ * while the monitor still pointed at it, the currentMonitorStatusId foreign key
+ * (ON DELETE NO ACTION) blocked the delete forever. This is the intermittent
+ * "Monitor records still reference it" failure in the Terraform E2E suite,
+ * where the monitors latched onto the fixture's freshly-created "TF Operational"
+ * instead of the seeded default.
+ *
+ * The fix orders the lookup by priority ascending (the seeded default
+ * operational status is priority 0) then createdAt ascending, so a monitor
+ * always adopts the project's canonical operational status. These tests pin
+ * that ordering and the resulting assignment.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const DEFAULT_OPERATIONAL_STATUS_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+
+describe("MonitorService.onBeforeCreate operational status selection", () => {
+  let findOneByMock: MockFunction;
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+
+    // The monitorSteps project-scope validator needs a DB; it is not under test.
+    jest
+      .spyOn(
+        MonitorStepsProjectValidator,
+        "validateMonitorStepsBelongToProject",
+      )
+      .mockResolvedValue(undefined as never);
+
+    // Billing gate needs a DB; return a plan that passes both checks.
+    jest.spyOn(ProjectService, "getCurrentPlan").mockResolvedValue({
+      plan: PlanType.Growth,
+      isSubscriptionUnpaid: false,
+      isFreePlan: false,
+    } as never);
+
+    // Capture the query/sort the operational-status lookup is made with.
+    findOneByMock = getJestMockFunction();
+    findOneByMock.mockImplementation(() => {
+      const status: MonitorStatus = new MonitorStatus();
+      status.id = DEFAULT_OPERATIONAL_STATUS_ID;
+      return Promise.resolve(status);
+    });
+    jest
+      .spyOn(MonitorStatusService, "findOneBy")
+      .mockImplementation(findOneByMock as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  const runOnBeforeCreate: () => Promise<Monitor> =
+    async (): Promise<Monitor> => {
+      const monitor: Monitor = new Monitor();
+      monitor.monitorType = MonitorType.Manual;
+
+      const createBy: CreateBy<Monitor> = {
+        data: monitor,
+        props: { isRoot: true, tenantId: PROJECT_ID },
+      } as CreateBy<Monitor>;
+
+      await (
+        MonitorService as unknown as {
+          onBeforeCreate: (c: CreateBy<Monitor>) => Promise<unknown>;
+        }
+      ).onBeforeCreate(createBy);
+
+      return createBy.data as Monitor;
+    };
+
+  test("selects the operational status with a deterministic priority-ascending sort", async () => {
+    await runOnBeforeCreate();
+
+    expect(findOneByMock).toHaveBeenCalledTimes(1);
+    const findArg: FindOneBy<MonitorStatus> = findOneByMock.mock
+      .calls[0]![0] as FindOneBy<MonitorStatus>;
+
+    // Only operational states are considered.
+    expect(
+      (findArg.query as { isOperationalState?: boolean }).isOperationalState,
+    ).toBe(true);
+
+    /*
+     * The sort must be explicit and deterministic. `priority` ascending picks
+     * the primary operational status (the seeded default is priority 0);
+     * without it findOneBy would fall back to createdAt DESC and grab the
+     * newest operational status.
+     */
+    const sort: Partial<Record<string, SortOrder>> = findArg.sort as Partial<
+      Record<string, SortOrder>
+    >;
+    expect(sort).toBeDefined();
+    expect(sort["priority"]).toBe(SortOrder.Ascending);
+    // createdAt ascending is the stable tie-breaker (oldest wins), never DESC.
+    expect(sort["createdAt"]).toBe(SortOrder.Ascending);
+    expect(sort["createdAt"]).not.toBe(SortOrder.Descending);
+  });
+
+  test("assigns the selected operational status as the monitor's currentMonitorStatusId", async () => {
+    const monitor: Monitor = await runOnBeforeCreate();
+
+    expect(monitor.currentMonitorStatusId?.toString()).toBe(
+      DEFAULT_OPERATIONAL_STATUS_ID.toString(),
+    );
+  });
+});