@oneuptime/common 11.5.12 → 11.6.0

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

@@ -0,0 +1,232 @@
+import NetworkDeviceDiscoveryScanService from "../../../Server/Services/NetworkDeviceDiscoveryScanService";
+import ModelPermission from "../../../Server/Types/Database/Permissions/Index";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import NetworkDeviceDiscoveryScan from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Probe from "../../../Models/DatabaseModels/Probe";
+import ObjectID from "../../../Types/ObjectID";
+import OneUptimeDate from "../../../Types/Date";
+import { JSONObject } from "../../../Types/JSON";
+import Select from "../../../Server/Types/Database/Select";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+
+type ScanUpdateData = UpdateBy<NetworkDeviceDiscoveryScan>["data"];
+
+/*
+ * Regression tests for the bug that left every SNMP discovery scan stuck in
+ * "Pending": update `data` passed as a full model instance carries the
+ * non-column own properties of DatabaseBaseModel (column initializers plus
+ * `isPermissionIf = {}`). _updateBy used to turn every data key into a select
+ * column for its internal find, and the unknown `isPermissionIf` column made
+ * that find throw `TableColumnMetadata not found for isPermissionIf column`,
+ * failing the whole update — so the probe-ingest list endpoint 400'd before
+ * it could claim a scan.
+ *
+ * sanitizeUpdateData is the fix: model instances are stripped down to their
+ * set table columns before the update pipeline runs.
+ */
+
+describe("DatabaseService.sanitizeUpdateData — model instances become plain column data", () => {
+  test("a fresh model instance really does carry non-column own properties (the trap this guards against)", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+
+    /*
+     * If this stops holding, the base model changed shape and these tests
+     * (and sanitizeUpdateData itself) should be revisited.
+     */
+    expect(Object.keys(scan)).toContain("isPermissionIf");
+  });
+
+  test("keeps only the columns that were actually set", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+    scan.status = "In Progress";
+    scan.startedAt = OneUptimeDate.getCurrentDate();
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](scan as unknown as ScanUpdateData);
+
+    expect(Object.keys(data as JSONObject).sort()).toEqual([
+      "startedAt",
+      "status",
+    ]);
+    expect((data as JSONObject)["status"]).toBe("In Progress");
+    expect((data as JSONObject)["startedAt"]).toBeInstanceOf(Date);
+  });
+
+  test("the result is a plain object, not a model instance", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+    scan.status = "Completed";
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](scan as unknown as ScanUpdateData);
+
+    expect(data).not.toBeInstanceOf(DatabaseBaseModel);
+    expect(Object.getPrototypeOf(data)).toBe(Object.prototype);
+  });
+
+  test("drops isPermissionIf and every other non-column own property", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+    scan.status = "Completed";
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](scan as unknown as ScanUpdateData);
+
+    expect(Object.keys(data as JSONObject)).not.toContain("isPermissionIf");
+  });
+
+  test("drops columns left undefined so they cannot become writes", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+    scan.status = "Failed";
+    // cidr, snmpVersion, statusMessage etc. stay undefined.
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](scan as unknown as ScanUpdateData);
+
+    expect(Object.keys(data as JSONObject)).toEqual(["status"]);
+  });
+
+  test("preserves explicit null so columns can still be cleared", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+    scan.status = "Pending";
+    (scan as any).statusMessage = null;
+    (scan as any).nextScanAt = null;
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](scan as unknown as ScanUpdateData);
+
+    expect((data as JSONObject)["statusMessage"]).toBeNull();
+    expect((data as JSONObject)["nextScanAt"]).toBeNull();
+  });
+
+  test("drops _id, createdAt, updatedAt and version even when set (loaded-model updates must not redirect the write or forge timestamps)", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan(
+      ObjectID.generate(),
+    );
+    scan.status = "Completed";
+    (scan as any).createdAt = OneUptimeDate.getCurrentDate();
+    (scan as any).updatedAt = OneUptimeDate.getCurrentDate();
+    (scan as any).version = 7;
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](scan as unknown as ScanUpdateData);
+
+    expect(Object.keys(data as JSONObject)).toEqual(["status"]);
+  });
+
+  test("keeps entity relation columns that were set", () => {
+    const probeId: ObjectID = ObjectID.generate();
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+    scan.status = "Pending";
+    scan.probe = new Probe(probeId);
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](scan as unknown as ScanUpdateData);
+
+    expect((data as JSONObject)["probe"]).toBeInstanceOf(Probe);
+    expect(((data as JSONObject)["probe"] as Probe).id?.toString()).toBe(
+      probeId.toString(),
+    );
+  });
+
+  test("plain objects pass through by reference, unknown keys and all (typos must keep failing loudly)", () => {
+    const plain: JSONObject = {
+      status: "Completed",
+      someTypoColumn: 1,
+    };
+
+    const data: ScanUpdateData = NetworkDeviceDiscoveryScanService[
+      "sanitizeUpdateData"
+    ](plain as unknown as ScanUpdateData);
+
+    expect(data).toBe(plain);
+    expect(Object.keys(data as JSONObject)).toContain("someTypoColumn");
+  });
+});
+
+describe("DatabaseService._updateBy — updateOneById with a model instance no longer poisons the internal find", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("select columns for the internal find contain only real columns from the data", async () => {
+    const scanId: ObjectID = ObjectID.generate();
+
+    const foundItem: NetworkDeviceDiscoveryScan =
+      new NetworkDeviceDiscoveryScan();
+    foundItem._id = scanId.toString();
+
+    // eslint-disable-next-line @typescript-eslint/typedef
+    const findBySpy = jest
+      .spyOn(NetworkDeviceDiscoveryScanService as any, "_findBy")
+      .mockResolvedValue([foundItem] as never);
+
+    // eslint-disable-next-line @typescript-eslint/typedef
+    const saveMock = jest.fn((item: unknown) => {
+      return Promise.resolve(item);
+    });
+    jest
+      .spyOn(NetworkDeviceDiscoveryScanService, "getRepository")
+      .mockReturnValue({ save: saveMock } as never);
+
+    // Permission layer is not under test here and needs no DB.
+    jest
+      .spyOn(ModelPermission, "checkUpdatePermissionByModel")
+      .mockResolvedValue(undefined as never);
+    jest
+      .spyOn(ModelPermission, "checkUpdateQueryPermissions")
+      .mockImplementation(((
+        _modelType: unknown,
+        query: unknown,
+      ): Promise<unknown> => {
+        return Promise.resolve(query);
+      }) as never);
+
+    const inProgress: NetworkDeviceDiscoveryScan =
+      new NetworkDeviceDiscoveryScan();
+    inProgress.status = "In Progress";
+    inProgress.startedAt = OneUptimeDate.getCurrentDate();
+
+    /*
+     * Before the fix this call rejected with "TableColumnMetadata not found
+     * for isPermissionIf column" — reproducing exactly why discovery scans
+     * never left Pending.
+     */
+    await expect(
+      NetworkDeviceDiscoveryScanService.updateOneById({
+        id: scanId,
+        data: inProgress as unknown as UpdateBy<NetworkDeviceDiscoveryScan>["data"],
+        props: {
+          isRoot: true,
+        },
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(findBySpy).toHaveBeenCalledTimes(1);
+    const findArgs: { select: Select<NetworkDeviceDiscoveryScan> } = (
+      findBySpy.mock.calls[0] as Array<any>
+    )[0];
+    const selectedColumns: Array<string> = Object.keys(findArgs.select);
+
+    // The data columns plus _id and the tenant column — nothing else.
+    expect(selectedColumns.sort()).toEqual(
+      ["_id", "projectId", "startedAt", "status"].sort(),
+    );
+    expect(selectedColumns).not.toContain("isPermissionIf");
+
+    // The persisted payload is the plain data plus the located row's _id.
+    expect(saveMock).toHaveBeenCalledTimes(1);
+    const savedItem: JSONObject = saveMock.mock.calls[0]![0] as JSONObject;
+    expect(Object.keys(savedItem).sort()).toEqual(
+      ["_id", "startedAt", "status"].sort(),
+    );
+    expect(savedItem["status"]).toBe("In Progress");
+    expect(savedItem["_id"]).toBe(scanId.toString());
+  });
+});

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

@@ -6,6 +6,7 @@ import ServiceService from "../../../Server/Services/ServiceService";
 import CodeRepositoryService from "../../../Server/Services/CodeRepositoryService";
 import AIAgentService from "../../../Server/Services/AIAgentService";
 import AIRunService from "../../../Server/Services/AIRunService";
+import AIAgentTaskPullRequestService from "../../../Server/Services/AIAgentTaskPullRequestService";
 import { RepoResolution } from "../../../Server/Utils/CodeRepository/StackTraceRepoResolver";
 import FindOneBy from "../../../Server/Types/Database/FindOneBy";
 import TelemetryException from "../../../Models/DatabaseModels/TelemetryException";
@@ -37,12 +38,19 @@ const projectId: ObjectID = ObjectID.generate();
 const exceptionId: ObjectID = ObjectID.generate();
 const serviceId: ObjectID = ObjectID.generate();
 
-function fakeException(): TelemetryException {
+function fakeException(
+  overrides: Partial<TelemetryException> = {},
+): TelemetryException {
   return {
     id: exceptionId,
     projectId: projectId,
     primaryEntityId: serviceId,
+    message: "Failed to charge card for user 123",
+    exceptionType: "PaymentError",
     stackTrace: "at charge (/app/src/billing/charge.ts:12:5)",
+    isResolved: false,
+    isArchived: false,
+    ...overrides,
   } as unknown as TelemetryException;
 }
 
@@ -91,6 +99,14 @@ function mockReadinessOk(): void {
     limitInTokens: null,
     usedTokensToday: 0,
   });
+
+  /*
+   * Cross-group duplicate guard collaborators: no non-terminal runs and no
+   * open AI pull requests unless a test overrides these. findBy on the
+   * exception service itself is only reached when candidates exist.
+   */
+  jest.spyOn(AIRunService, "findBy").mockResolvedValue([]);
+  jest.spyOn(AIAgentTaskPullRequestService, "findBy").mockResolvedValue([]);
 }
 
 describe("TelemetryExceptionService.createCodeFixRunForException", () => {
@@ -283,6 +299,194 @@ describe("TelemetryExceptionService.createCodeFixRunForException", () => {
       }),
     );
   });
+
+  test("rejects resolved and archived exceptions server-side", async () => {
+    mockReadinessOk();
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    jest
+      .spyOn(TelemetryExceptionService, "findOneById")
+      .mockResolvedValue(fakeException({ isResolved: true }));
+
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow(/marked as resolved/);
+
+    jest
+      .spyOn(TelemetryExceptionService, "findOneById")
+      .mockResolvedValue(fakeException({ isArchived: true }));
+
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow(/archived/);
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("a declined AI fix (aiFixDeclinedAt) blocks the automatic lane but a user click clears the stamp and proceeds", async () => {
+    mockReadinessOk();
+
+    jest
+      .spyOn(TelemetryExceptionService, "findOneById")
+      .mockResolvedValue(fakeException({ aiFixDeclinedAt: new Date() }));
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue({ id: ObjectID.generate() } as unknown as AIRun);
+    const clearStamp: jest.SpyInstance = jest
+      .spyOn(TelemetryExceptionService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    // System-triggered (no userId): blocked.
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow(/closed without merging/);
+    expect(create).not.toHaveBeenCalled();
+
+    // A human click: clears the stamp and creates the run.
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true, userId: ObjectID.generate() },
+      }),
+    ).resolves.toBeDefined();
+
+    expect(clearStamp).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: exceptionId,
+        data: expect.objectContaining({ aiFixDeclinedAt: null }),
+      }),
+    );
+    expect(create).toHaveBeenCalled();
+  });
+
+  test("the decline stamp is scoped to FixException: other recipes are neither blocked by it nor clear it", async () => {
+    mockReadinessOk();
+
+    jest
+      .spyOn(TelemetryExceptionService, "findOneById")
+      .mockResolvedValue(fakeException({ aiFixDeclinedAt: new Date() }));
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue({ id: ObjectID.generate() } as unknown as AIRun);
+    const exceptionUpdates: jest.SpyInstance = jest
+      .spyOn(TelemetryExceptionService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    /*
+     * A user asking for a regression TEST on a group whose FIX a human
+     * declined: the test run proceeds, and — critically — the fix-decline
+     * suppression stays in force (the user never overrode the fix).
+     */
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true, userId: ObjectID.generate() },
+        taskType: CodeFixTaskType.WriteRegressionTest,
+      }),
+    ).resolves.toBeDefined();
+
+    expect(create).toHaveBeenCalled();
+    expect(exceptionUpdates).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ aiFixDeclinedAt: null }),
+      }),
+    );
+  });
+
+  test("cross-group duplicate guard: a similar exception (same type + normalized message) with an active run blocks creation", async () => {
+    mockReadinessOk();
+
+    /*
+     * The observed flood shape: one throw site interpolating a different
+     * UUID per request splinters into one fingerprint (and one exception
+     * group) per value. Normalization collapses both messages to
+     * `...uuid: "<UUID>"`, which is what the guard compares.
+     */
+    jest.spyOn(TelemetryExceptionService, "findOneById").mockResolvedValue(
+      fakeException({
+        message:
+          'invalid input syntax for type uuid: "550e8400-e29b-41d4-a716-446655440000"',
+        exceptionType: "QueryFailedError",
+      }),
+    );
+
+    // Per-exception guard finds nothing for THIS exception...
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+
+    /*
+     * ...but another exception group — same root cause, different
+     * interpolated value — has a non-terminal FixException run.
+     */
+    const similarExceptionId: ObjectID = ObjectID.generate();
+    jest.spyOn(AIRunService, "findBy").mockResolvedValue([
+      {
+        triggeredByTelemetryExceptionId: similarExceptionId,
+      } as unknown as AIRun,
+    ]);
+    jest.spyOn(TelemetryExceptionService, "findBy").mockResolvedValue([
+      {
+        _id: similarExceptionId.toString(),
+        message:
+          'invalid input syntax for type uuid: "123e4567-e89b-12d3-a456-426614174000"',
+        exceptionType: "QueryFailedError",
+      } as unknown as TelemetryException,
+    ]);
+
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow(/similar exception/);
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("cross-group duplicate guard: a DIFFERENT normalized message does not block", async () => {
+    mockReadinessOk();
+
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+
+    const otherExceptionId: ObjectID = ObjectID.generate();
+    jest.spyOn(AIRunService, "findBy").mockResolvedValue([
+      {
+        triggeredByTelemetryExceptionId: otherExceptionId,
+      } as unknown as AIRun,
+    ]);
+    jest.spyOn(TelemetryExceptionService, "findBy").mockResolvedValue([
+      {
+        _id: otherExceptionId.toString(),
+        message: "Connection refused to redis",
+        exceptionType: "ConnectionError",
+      } as unknown as TelemetryException,
+    ]);
+
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue({ id: ObjectID.generate() } as unknown as AIRun);
+
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      }),
+    ).resolves.toBeDefined();
+
+    expect(create).toHaveBeenCalled();
+  });
 });
 
 /*

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

@@ -0,0 +1,107 @@
+import NetworkDeviceDiscoveryScan from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import NetworkDeviceDiscoveryScanService from "../../../Server/Services/NetworkDeviceDiscoveryScanService";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * Regression tests for the second layer of the discovery-scan "stuck
+ * Pending" bug (the first layer — model instances poisoning the internal
+ * find's select columns — is covered in
+ * DatabaseServiceSanitizeUpdateData.test.ts).
+ *
+ * DatabaseService._updateBy builds the row it saves as a merge of the
+ * located row's _id and the caller's update data. With the old merge order
+ * `{ _id: item._id, ...data }`, update data carrying an own `_id: undefined`
+ * property (a fresh model instance before sanitizeUpdateData existed, or a
+ * plain object that spells it out) clobbered the located row's id — TypeORM
+ * save() saw no primary key, INSERTed a new row instead of updating, and
+ * died on the first NOT NULL column.
+ *
+ * These tests pin the fixed merge order: the located row's _id must win no
+ * matter what shape the update data takes. _findBy is mocked out, so this
+ * exercises the save-payload merge in isolation.
+ */
+
+type SavedRow = { _id?: string; status?: string; startedAt?: Date };
+
+function mockPersistence(existingRowId: string): jest.Mock {
+  const existing: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+  existing._id = existingRowId;
+
+  jest
+    .spyOn(NetworkDeviceDiscoveryScanService as any, "_findBy")
+    .mockResolvedValue([existing] as never);
+
+  const save: jest.Mock = jest
+    .fn()
+    .mockImplementation(async (row: unknown): Promise<unknown> => {
+      return row;
+    });
+
+  jest
+    .spyOn(NetworkDeviceDiscoveryScanService, "getRepository")
+    .mockReturnValue({ save } as any);
+
+  return save;
+}
+
+describe("DatabaseService.updateOneById — saved row keeps the located row's _id", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("when data is a fresh model instance (own undefined _id property)", async () => {
+    const rowId: string = ObjectID.generate().toString();
+    const save: jest.Mock = mockPersistence(rowId);
+
+    const data: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+    data.status = "In Progress";
+    data.startedAt = new Date();
+
+    // The bug's precondition: the instance really does carry _id: undefined.
+    expect(Object.keys(data)).toContain("_id");
+
+    await NetworkDeviceDiscoveryScanService.updateOneById({
+      id: new ObjectID(rowId),
+      data: data as never,
+      props: { isRoot: true },
+    });
+
+    expect(save).toHaveBeenCalledTimes(1);
+    const saved: SavedRow = save.mock.calls[0]![0] as SavedRow;
+    expect(saved._id).toBe(rowId);
+    expect(saved.status).toBe("In Progress");
+  });
+
+  test("when data is a plain partial object", async () => {
+    const rowId: string = ObjectID.generate().toString();
+    const save: jest.Mock = mockPersistence(rowId);
+
+    await NetworkDeviceDiscoveryScanService.updateOneById({
+      id: new ObjectID(rowId),
+      data: { status: "In Progress" } as never,
+      props: { isRoot: true },
+    });
+
+    expect(save).toHaveBeenCalledTimes(1);
+    const saved: SavedRow = save.mock.calls[0]![0] as SavedRow;
+    expect(saved._id).toBe(rowId);
+    expect(saved.status).toBe("In Progress");
+  });
+
+  test("when data is a plain object that spells out _id: undefined", async () => {
+    const rowId: string = ObjectID.generate().toString();
+    const save: jest.Mock = mockPersistence(rowId);
+
+    await NetworkDeviceDiscoveryScanService.updateOneById({
+      id: new ObjectID(rowId),
+      data: { _id: undefined, status: "In Progress" } as never,
+      props: { isRoot: true },
+    });
+
+    expect(save).toHaveBeenCalledTimes(1);
+    const saved: SavedRow = save.mock.calls[0]![0] as SavedRow;
+    expect(saved._id).toBe(rowId);
+    expect(saved.status).toBe("In Progress");
+  });
+});