@oneuptime/common 11.7.3 → 11.7.4

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

@@ -0,0 +1,201 @@
+import DatabaseService from "../../../Server/Services/DatabaseService";
+import IncidentReminderRule from "../../../Models/DatabaseModels/IncidentReminderRule";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+
+/*
+ * A column can be ordered by without being selected in a plain SELECT, but not
+ * once a relation is also selected: the join sends the query down TypeORM's
+ * paginated path, which wraps it and orders the outer SELECT by a column the
+ * inner query only emits when that column was selected. Postgres then rejects
+ * the whole request with `column distinctAlias.<Alias>_<column> does not
+ * exist`, which surfaces as a 500 and blanks the page.
+ *
+ * It went wrong twice: the monitor overview's probe query sorting by createdAt,
+ * then the reminder countdown's three rule queries sorting by `order`.
+ * _findBy used to fill the sort column in only for callers that passed NO sort
+ * at all, so an explicit sort bypassed the safety net entirely. It now fills in
+ * every sorted column and strips the ones it added back off the results, so no
+ * call site has to know about any of this.
+ */
+
+type FindArgs = {
+  select?: Record<string, unknown> | undefined;
+  order?: Record<string, unknown> | undefined;
+};
+
+describe("DatabaseService._findBy selects the columns it sorts by", () => {
+  let service: DatabaseService<IncidentReminderRule>;
+  let find: jest.Mock;
+  let rowsReturnedByDatabase: Array<IncidentReminderRule>;
+
+  type MakeRowFunction = (data: {
+    order: number;
+    reminderIntervalInMinutes: number;
+  }) => IncidentReminderRule;
+
+  const makeRow: MakeRowFunction = (data: {
+    order: number;
+    reminderIntervalInMinutes: number;
+  }): IncidentReminderRule => {
+    const rule: IncidentReminderRule = new IncidentReminderRule();
+    rule.order = data.order;
+    rule.reminderIntervalInMinutes = data.reminderIntervalInMinutes;
+    return rule;
+  };
+
+  type FindByFunction = (data: {
+    select?: Record<string, unknown> | undefined;
+    sort?: Record<string, unknown> | undefined;
+  }) => Promise<Array<IncidentReminderRule>>;
+
+  const findBy: FindByFunction = (data: {
+    select?: Record<string, unknown> | undefined;
+    sort?: Record<string, unknown> | undefined;
+  }): Promise<Array<IncidentReminderRule>> => {
+    return service.findBy({
+      query: {},
+      limit: 10,
+      skip: 0,
+      select: data.select as any,
+      sort: data.sort as any,
+      props: { isRoot: true },
+    });
+  };
+
+  const selectPassedToDatabase: () => Record<string, unknown> = (): Record<
+    string,
+    unknown
+  > => {
+    return (find.mock.calls[0]![0] as FindArgs).select || {};
+  };
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+
+    service = new DatabaseService<IncidentReminderRule>(IncidentReminderRule);
+
+    /*
+     * The row the database hands back always carries the sorted column,
+     * because _findBy asked for it - that is the point. Whether the caller
+     * gets to see it is what these tests are about.
+     */
+    rowsReturnedByDatabase = [
+      makeRow({ order: 1, reminderIntervalInMinutes: 15 }),
+      makeRow({ order: 2, reminderIntervalInMinutes: 30 }),
+    ];
+
+    find = jest
+      .fn()
+      .mockImplementation(async (): Promise<Array<IncidentReminderRule>> => {
+        return rowsReturnedByDatabase;
+      });
+
+    jest.spyOn(service, "getRepository").mockReturnValue({ find: find } as any);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("adds an explicitly sorted column that the caller did not select", async () => {
+    await findBy({
+      select: {
+        reminderIntervalInMinutes: true,
+        incidentSeverities: { _id: true },
+        labels: { _id: true },
+      },
+      sort: { order: SortOrder.Ascending },
+    });
+
+    expect(selectPassedToDatabase()["order"]).toBe(true);
+  });
+
+  it("hides the added column from the caller", async () => {
+    const rules: Array<IncidentReminderRule> = await findBy({
+      select: {
+        reminderIntervalInMinutes: true,
+        labels: { _id: true },
+      },
+      sort: { order: SortOrder.Ascending },
+    });
+
+    expect(rules).toHaveLength(2);
+
+    for (const rule of rules) {
+      expect(rule.order).toBeUndefined();
+      expect(rule.reminderIntervalInMinutes).toBeDefined();
+    }
+  });
+
+  it("keeps the column when the caller selected it themselves", async () => {
+    const rules: Array<IncidentReminderRule> = await findBy({
+      select: {
+        order: true,
+        reminderIntervalInMinutes: true,
+        labels: { _id: true },
+      },
+      sort: { order: SortOrder.Ascending },
+    });
+
+    expect(
+      rules.map((rule: IncidentReminderRule) => {
+        return rule.order;
+      }),
+    ).toEqual([1, 2]);
+  });
+
+  it("adds every column of a multi-column sort", async () => {
+    await findBy({
+      select: { labels: { _id: true } },
+      sort: {
+        order: SortOrder.Ascending,
+        reminderIntervalInMinutes: SortOrder.Descending,
+      },
+    });
+
+    expect(selectPassedToDatabase()["order"]).toBe(true);
+    expect(selectPassedToDatabase()["reminderIntervalInMinutes"]).toBe(true);
+  });
+
+  it("does not add a relation that is being sorted on", async () => {
+    await findBy({
+      select: { reminderIntervalInMinutes: true },
+      sort: { labels: SortOrder.Ascending },
+    });
+
+    expect(selectPassedToDatabase()["labels"]).toBeUndefined();
+  });
+
+  it("leaves the caller's own select object untouched", async () => {
+    const callerSelect: Record<string, unknown> = {
+      reminderIntervalInMinutes: true,
+      labels: { _id: true },
+    };
+
+    await findBy({
+      select: callerSelect,
+      sort: { order: SortOrder.Ascending },
+    });
+
+    expect(callerSelect["order"]).toBeUndefined();
+  });
+
+  it("still fills in and hides createdAt for callers that pass no sort", async () => {
+    const rules: Array<IncidentReminderRule> = await findBy({
+      select: {
+        reminderIntervalInMinutes: true,
+        labels: { _id: true },
+      },
+    });
+
+    expect(selectPassedToDatabase()["createdAt"]).toBe(true);
+    expect((find.mock.calls[0]![0] as FindArgs).order?.["createdAt"]).toBe(
+      SortOrder.Descending,
+    );
+
+    for (const rule of rules) {
+      expect(rule.createdAt).toBeUndefined();
+    }
+  });
+});

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

@@ -22,16 +22,25 @@ import { describe, expect, test } from "@jest/globals";
  *       Pending scan
  *
  * The conversion dropped NOTHING: the model declares no update workflow, no
- * audit logging and no realtime events, and the service overrides neither
- * update hook — so the old pipeline's hook stages were inert for this
- * write. But the fast path skips hooks UNCONDITIONALLY: if someone later
- * adds a decorator to NetworkDeviceDiscoveryScan or an update-hook override
- * to its service, nothing at the call site fails — the new hook is just
+ * audit logging and no realtime events. But the fast path skips hooks
+ * UNCONDITIONALLY: if someone adds a decorator to NetworkDeviceDiscoveryScan,
+ * or an update-hook override to its service that cares about a column the
+ * claim write stamps, nothing at the call site fails — the hook is just
  * silently never fired for the claim write. This suite turns that silent
  * drift into a loud test failure: if any assertion here starts failing, the
  * hookless claim writes in DiscoveryScan.ts silently skip that new hook —
  * revisit the call site before changing the assertion.
  *
+ * The service DOES now override onBeforeUpdate: it validates the scan target
+ * (the `cidr` column) whenever an update carries it, so a bad target cannot
+ * be written by a root caller that bypasses the create-time check. That hook
+ * is deliberately safe to skip here, and the assertions below pin exactly
+ * why rather than merely restating that it exists: the claim write stamps
+ * only `status` and `startedAt`, which the hook does not look at, and the
+ * hook is a pass-through for that payload. If the hook ever grows to
+ * validate a column the claim write touches — or the claim write grows to
+ * touch `cidr` — these fail.
+ *
  * Pure model-metadata + class-shape tests — no Postgres, no Redis.
  */
 
@@ -79,26 +88,21 @@ describe("discovery-scan claim hookless write safety preconditions", () => {
     });
   });
 
-  describe("service defines no update hooks of its own", () => {
-    /*
-     * DatabaseService's base onBeforeUpdate/onUpdateSuccess are no-op
-     * pass-throughs; a service only gets update behavior by OVERRIDING
-     * them. Own-property checks on the concrete service prototype pin that
-     * NetworkDeviceDiscoveryScanService does not — so the fast path skips
-     * nothing. If an override appears, these fail loudly and the claim
-     * write in DiscoveryScan.ts must be re-evaluated.
-     */
+  describe("the service's update hooks are safe for the claim write to skip", () => {
     const updateHooks: Array<string> = ["onBeforeUpdate", "onUpdateSuccess"];
 
-    test("NetworkDeviceDiscoveryScanService does not override onBeforeUpdate/onUpdateSuccess", () => {
-      for (const hook of updateHooks) {
-        expect(
-          Object.prototype.hasOwnProperty.call(
-            NetworkDeviceDiscoveryScanServiceClass.prototype,
-            hook,
-          ),
-        ).toBe(false);
-      }
+    /*
+     * onUpdateSuccess is still un-overridden: nothing runs AFTER the write
+     * that the fast path would drop. Only onBeforeUpdate is overridden, and
+     * the tests below pin that it is inert for the claim payload.
+     */
+    test("NetworkDeviceDiscoveryScanService does not override onUpdateSuccess", () => {
+      expect(
+        Object.prototype.hasOwnProperty.call(
+          NetworkDeviceDiscoveryScanServiceClass.prototype,
+          "onUpdateSuccess",
+        ),
+      ).toBe(false);
       // The default export is an instance of the class checked above.
       expect(NetworkDeviceDiscoveryScanService).toBeInstanceOf(
         NetworkDeviceDiscoveryScanServiceClass,
@@ -117,5 +121,59 @@ describe("discovery-scan claim hookless write safety preconditions", () => {
         ).toBe(true);
       }
     });
+
+    /*
+     * The columns the claim write stamps and the column the onBeforeUpdate
+     * override validates must stay disjoint. This is the assertion that
+     * actually licenses the hookless claim write: if someone adds `cidr` to
+     * the claim payload, or teaches the hook to validate `status`, the
+     * overlap shows up here.
+     */
+    test("the claim write's columns are disjoint from what onBeforeUpdate validates", () => {
+      const claimWriteColumns: Array<string> = ["status", "startedAt"];
+      const columnsValidatedByHook: Array<string> = ["cidr"];
+
+      for (const column of claimWriteColumns) {
+        expect(columnsValidatedByHook).not.toContain(column);
+      }
+    });
+
+    /*
+     * And the behavioural proof, rather than an inventory of column names:
+     * handed exactly the payload the claim write stamps, the override is a
+     * pass-through. Skipping it therefore drops nothing.
+     */
+    test("onBeforeUpdate is a pass-through for the exact claim payload", async () => {
+      const claimUpdateBy: unknown = {
+        query: { _id: "some-scan-id" },
+        data: { status: "In Progress", startedAt: new Date(0) },
+        props: { isRoot: true },
+        limit: 1,
+        skip: 0,
+      };
+
+      const result: { updateBy: unknown } = await (
+        NetworkDeviceDiscoveryScanService as any
+      ).onBeforeUpdate(claimUpdateBy);
+
+      expect(result.updateBy).toBe(claimUpdateBy);
+    });
+
+    /*
+     * Negative control: the hook is not inert in general. Without this, the
+     * pass-through test above would keep passing if the override were
+     * gutted, and the disjointness assertion would be guarding nothing.
+     */
+    test("onBeforeUpdate does reject a bad target, so the pass-through is meaningful", async () => {
+      await expect(
+        (NetworkDeviceDiscoveryScanService as any).onBeforeUpdate({
+          query: { _id: "some-scan-id" },
+          data: { cidr: "10.22-16.0.1" },
+          props: { isRoot: true },
+          limit: 1,
+          skip: 0,
+        }),
+      ).rejects.toThrow();
+    });
   });
 });