@oneuptime/common 11.7.2 → 11.7.4

package/Tests/Server/API/CommonAPIAuthGuard.test.ts

@@ -315,3 +315,167 @@ describe("CommonAPI.assertAuthenticatedProjectMember", () => {
     });
   });
 });
+
+/*
+ * Tests for CommonAPI.assertResourceBelongsToProject — the companion guard
+ * for custom routes whose path carries a resource id.
+ * assertAuthenticatedProjectMember only proves the caller belongs to the
+ * project it claimed in the `tenantid` header; without this second check a
+ * member of project A could hand the route project B's resource id and have
+ * it acted on as root.
+ */
+describe("CommonAPI.assertResourceBelongsToProject", () => {
+  test("does not throw when the resource belongs to the authorized project", () => {
+    const projectId: ObjectID = ObjectID.generate();
+
+    expect(() => {
+      CommonAPI.assertResourceBelongsToProject({
+        resourceProjectId: projectId,
+        projectId: projectId,
+      });
+    }).not.toThrow();
+  });
+
+  test("compares by string value, not by ObjectID instance", () => {
+    const projectIdString: string = ObjectID.generate().toString();
+
+    expect(() => {
+      CommonAPI.assertResourceBelongsToProject({
+        resourceProjectId: new ObjectID(projectIdString),
+        projectId: new ObjectID(projectIdString),
+      });
+    }).not.toThrow();
+  });
+
+  test("throws NotAuthorizedException when the resource belongs to another project", () => {
+    const thrown: unknown = captureThrown(() => {
+      CommonAPI.assertResourceBelongsToProject({
+        resourceProjectId: ObjectID.generate(),
+        projectId: ObjectID.generate(),
+      });
+    });
+
+    expect(thrown).toBeInstanceOf(NotAuthorizedException);
+    expect((thrown as Exception).message).toBe(
+      "You are not authorized to access this project's data.",
+    );
+  });
+
+  /*
+   * A row that was not found reaches the guard as undefined. It must be
+   * rejected exactly like a cross-project row, so the endpoint cannot be
+   * used to tell "id exists in another project" apart from "id does not
+   * exist".
+   */
+  test("throws NotAuthorizedException when the resource was not found", () => {
+    const thrown: unknown = captureThrown(() => {
+      CommonAPI.assertResourceBelongsToProject({
+        resourceProjectId: undefined,
+        projectId: ObjectID.generate(),
+      });
+    });
+
+    expect(thrown).toBeInstanceOf(NotAuthorizedException);
+    expect((thrown as Exception).message).toBe(
+      "You are not authorized to access this project's data.",
+    );
+  });
+
+  test("throws NotAuthorizedException when the resource carries a null projectId", () => {
+    expect(() => {
+      CommonAPI.assertResourceBelongsToProject({
+        resourceProjectId: null,
+        projectId: ObjectID.generate(),
+      });
+    }).toThrow(NotAuthorizedException);
+  });
+});
+
+/*
+ * Tests for CommonAPI.assertTenantScoped — the lighter guard for custom
+ * endpoints whose path carries only a resource id, so the project can only
+ * come from the `tenantid` header. Without it the request still reaches the
+ * handler, just with no tenant permissions, and the eventual tenant-scoped
+ * read fails as "You do not have permissions to read <model>" — a message
+ * that sends project owners hunting for a role they already hold. The guard
+ * exists to surface the real cause (a missing header) instead.
+ */
+describe("CommonAPI.assertTenantScoped", () => {
+  test("throws BadDataException naming the tenantid header when tenantId is missing", () => {
+    const props: DatabaseCommonInteractionProps = buildProps({
+      tenantId: undefined,
+      userId: ObjectID.generate(),
+    });
+
+    const thrown: unknown = captureThrown(() => {
+      CommonAPI.assertTenantScoped(props);
+    });
+
+    expect(thrown).toBeInstanceOf(BadDataException);
+    expect((thrown as Exception).message).toContain("Project ID is required");
+    expect((thrown as Exception).message).toContain("tenantid");
+  });
+
+  test("the message points at the header rather than at permissions", () => {
+    const thrown: unknown = captureThrown(() => {
+      CommonAPI.assertTenantScoped({});
+    });
+
+    /*
+     * The whole point of the guard: whatever it says must not look like the
+     * permissions error it replaces.
+     */
+    expect((thrown as Exception).message).toContain("tenantid");
+    expect((thrown as Exception).message).not.toContain("permission");
+  });
+
+  test("returns the tenant id when the request is project scoped", () => {
+    const projectId: ObjectID = ObjectID.generate();
+    const props: DatabaseCommonInteractionProps = buildProps({
+      tenantId: projectId,
+      userId: ObjectID.generate(),
+    });
+
+    expect(CommonAPI.assertTenantScoped(props)).toBe(projectId);
+  });
+
+  /*
+   * API-key callers are authenticated by ProjectMiddleware, which sets
+   * userType/tenantId and the tenant permission map but never userId. This
+   * guard must not lock them out — that is what separates it from
+   * assertAuthenticatedProjectMember.
+   */
+  test("accepts an API-key caller that has a tenant but no userId", () => {
+    const projectId: ObjectID = ObjectID.generate();
+    const permissions: Dictionary<UserTenantAccessPermission> = {};
+    permissions[projectId.toString()] = buildTenantPermission(projectId);
+
+    const props: DatabaseCommonInteractionProps = buildProps({
+      tenantId: projectId,
+      userId: undefined,
+      userTenantAccessPermission: permissions,
+    });
+
+    expect(() => {
+      CommonAPI.assertTenantScoped(props);
+    }).not.toThrow();
+  });
+
+  test("does not require membership — that stays with the tenant-scoped read", () => {
+    /*
+     * assertTenantScoped is a diagnostic for a missing header, not an
+     * authorization check. A caller who sends a tenant id for a project they
+     * are not a member of passes here and is rejected by the read itself, so
+     * adding this guard cannot loosen or tighten access.
+     */
+    const props: DatabaseCommonInteractionProps = buildProps({
+      tenantId: ObjectID.generate(),
+      userId: undefined,
+      userTenantAccessPermission: undefined,
+    });
+
+    expect(() => {
+      CommonAPI.assertTenantScoped(props);
+    }).not.toThrow();
+  });
+});

package/Tests/Server/API/ProbeAPI.test.ts

@@ -8,9 +8,14 @@ import {
 import Response from "../../../Server/Utils/Response";
 import { mockRouter } from "./Helpers";
 import { describe, expect, it } from "@jest/globals";
-import LIMIT_MAX from "../../../Types/Database/LimitMax";
+import MultiSearch from "../../../Types/BaseDatabase/MultiSearch";
+import { DEFAULT_LIMIT } from "../../../Types/Database/LimitMax";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import BadRequestException from "../../../Types/Exception/BadRequestException";
+import { JSONObject } from "../../../Types/JSON";
 import PositiveNumber from "../../../Types/PositiveNumber";
 import Probe from "../../../Models/DatabaseModels/Probe";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 
 jest.mock("../../../Server/Utils/Express", () => {
   return {
@@ -37,77 +42,441 @@ jest.mock("../../../Server/Utils/Response", () => {
 
 jest.mock("../../../Server/Services/ProbeService");
 
+type RequestOverrides = {
+  body?: JSONObject | undefined;
+  query?: JSONObject | undefined;
+};
+
 describe("ProbeAPI", () => {
-  let mockRequest: ExpressRequest;
   let mockResponse: ExpressResponse;
   let nextFunction: NextFunction;
 
+  const buildRequest: (overrides?: RequestOverrides) => ExpressRequest = (
+    overrides: RequestOverrides = {},
+  ): ExpressRequest => {
+    return {
+      body: overrides.body || {},
+      query: overrides.query || {},
+    } as unknown as ExpressRequest;
+  };
+
+  type CallGlobalProbesFunction = (
+    overrides?: RequestOverrides,
+  ) => Promise<ExpressRequest>;
+
+  const callGlobalProbes: CallGlobalProbesFunction = async (
+    overrides: RequestOverrides = {},
+  ): Promise<ExpressRequest> => {
+    const request: ExpressRequest = buildRequest(overrides);
+
+    await mockRouter
+      .match("post", "/probe/global-probes")
+      .handlerFunction(request, mockResponse, nextFunction);
+
+    return request;
+  };
+
   beforeEach(() => {
     new ProbeAPI();
-    mockRequest = {} as ExpressRequest;
     mockResponse = {
       send: jest.fn(),
       json: jest.fn(),
       status: jest.fn().mockReturnThis(),
     } as unknown as ExpressResponse;
     nextFunction = jest.fn();
+
+    ProbeService.findBy = jest.fn().mockResolvedValue([]);
+    ProbeService.countBy = jest.fn().mockResolvedValue(new PositiveNumber(0));
   });
 
-  it("should correctly handle global probes request", async () => {
-    // eslint-disable-next-line @typescript-eslint/typedef
-    const mockProbes = [{ id: "probe" }];
-    ProbeService.findBy = jest.fn().mockResolvedValue(mockProbes);
-    await mockRouter
-      .match("post", "/probe/global-probes")
-      .handlerFunction(mockRequest, mockResponse, nextFunction);
-
-    expect(ProbeService.findBy).toHaveBeenCalledWith({
-      query: {
-        isGlobalProbe: true,
-      },
-      select: {
-        name: true,
-        description: true,
-        connectionStatus: true,
-        lastAlive: true,
-        iconFileId: true,
-        /*
-         * The monitor create form pre-selects the probes that auto-enable on
-         * new monitors, and global probes are not project rows - this endpoint
-         * is the only place the browser can learn the flag for them.
-         */
-        shouldAutoEnableProbeOnNewMonitors: true,
-      },
-      props: {
-        isRoot: true,
-      },
-      skip: 0,
-      limit: LIMIT_MAX,
-    });
-
-    const response: jest.SpyInstance = jest.spyOn(
-      Response,
-      "sendEntityArrayResponse",
-    );
-    expect(response).toHaveBeenCalledWith(
-      mockRequest,
-      mockResponse,
-      mockProbes,
-      expect.any(PositiveNumber),
-      Probe,
-    );
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("defaults", () => {
+    it("should read the full select list when the caller asks for no fields", async () => {
+      const mockProbes: Array<Probe> = [{ id: "probe" } as unknown as Probe];
+      ProbeService.findBy = jest.fn().mockResolvedValue(mockProbes);
+
+      const request: ExpressRequest = await callGlobalProbes();
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith({
+        query: {
+          isGlobalProbe: true,
+        },
+        select: {
+          name: true,
+          description: true,
+          lastAlive: true,
+          iconFileId: true,
+          connectionStatus: true,
+          shouldAutoEnableProbeOnNewMonitors: true,
+        },
+        sort: {},
+        props: {
+          isRoot: true,
+        },
+        skip: new PositiveNumber(0),
+        limit: new PositiveNumber(DEFAULT_LIMIT),
+      });
+
+      const response: jest.SpyInstance = jest.spyOn(
+        Response,
+        "sendEntityArrayResponse",
+      );
+      expect(response).toHaveBeenCalledWith(
+        request,
+        mockResponse,
+        mockProbes,
+        expect.any(PositiveNumber),
+        Probe,
+      );
+    });
+  });
+
+  describe("query", () => {
+    it("should pass the caller's query through alongside isGlobalProbe", async () => {
+      await callGlobalProbes({
+        body: {
+          query: {
+            name: "probe-1",
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: {
+            name: "probe-1",
+            isGlobalProbe: true,
+          },
+        }),
+      );
+    });
+
+    it("should not let the caller widen the read past global probes", async () => {
+      await callGlobalProbes({
+        body: {
+          query: {
+            isGlobalProbe: false,
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: {
+            isGlobalProbe: true,
+          },
+        }),
+      );
+    });
+
+    it("should reject a filter on a field outside the select list", async () => {
+      await callGlobalProbes({
+        body: {
+          query: {
+            key: "secret-probe-key",
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).not.toHaveBeenCalled();
+      expect(nextFunction).toHaveBeenCalledWith(expect.any(BadDataException));
+    });
+
+    it("should allow a multi field search over allowed fields", async () => {
+      const search: MultiSearch = new MultiSearch({
+        fields: ["name", "description"],
+        value: "probe",
+      });
+
+      await callGlobalProbes({
+        body: {
+          query: {
+            _multiFieldSearch: search.toJSON(),
+          },
+        },
+      });
+
+      expect(nextFunction).not.toHaveBeenCalled();
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: expect.objectContaining({
+            _multiFieldSearch: expect.any(MultiSearch),
+            isGlobalProbe: true,
+          }),
+        }),
+      );
+    });
+
+    it("should reject a multi field search that reaches a field outside the select list", async () => {
+      const search: MultiSearch = new MultiSearch({
+        fields: ["name", "key"],
+        value: "a",
+      });
+
+      await callGlobalProbes({
+        body: {
+          query: {
+            _multiFieldSearch: search.toJSON(),
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).not.toHaveBeenCalled();
+      expect(nextFunction).toHaveBeenCalledWith(expect.any(BadDataException));
+    });
+  });
+
+  describe("select", () => {
+    it("should honour the caller's select", async () => {
+      await callGlobalProbes({
+        body: {
+          select: {
+            name: true,
+            shouldAutoEnableProbeOnNewMonitors: true,
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          select: {
+            name: true,
+            shouldAutoEnableProbeOnNewMonitors: true,
+          },
+        }),
+      );
+    });
+
+    it("should drop selected fields outside the select list", async () => {
+      await callGlobalProbes({
+        body: {
+          select: {
+            name: true,
+            key: true,
+            slug: true,
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          select: {
+            name: true,
+          },
+        }),
+      );
+    });
+
+    it("should not let an allowed field be turned into a relation select", async () => {
+      await callGlobalProbes({
+        body: {
+          select: {
+            name: {
+              key: true,
+            },
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          select: {
+            name: true,
+          },
+        }),
+      );
+    });
+
+    it("should fall back to the default select when nothing selectable is asked for", async () => {
+      await callGlobalProbes({
+        body: {
+          select: {
+            key: true,
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          select: {
+            name: true,
+            description: true,
+            lastAlive: true,
+            iconFileId: true,
+            connectionStatus: true,
+            shouldAutoEnableProbeOnNewMonitors: true,
+          },
+        }),
+      );
+    });
+  });
+
+  describe("sort", () => {
+    it("should honour the caller's sort", async () => {
+      await callGlobalProbes({
+        body: {
+          sort: {
+            name: SortOrder.Descending,
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sort: {
+            name: SortOrder.Descending,
+          },
+        }),
+      );
+    });
+
+    it("should reject a sort on a field outside the select list", async () => {
+      await callGlobalProbes({
+        body: {
+          sort: {
+            key: SortOrder.Ascending,
+          },
+        },
+      });
+
+      expect(ProbeService.findBy).not.toHaveBeenCalled();
+      expect(nextFunction).toHaveBeenCalledWith(expect.any(BadDataException));
+    });
+  });
+
+  describe("pagination", () => {
+    it("should read skip and limit from the query string", async () => {
+      await callGlobalProbes({
+        query: {
+          skip: "20",
+          limit: "5",
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          skip: new PositiveNumber(20),
+          limit: new PositiveNumber(5),
+        }),
+      );
+    });
+
+    it("should read skip and limit from the body", async () => {
+      await callGlobalProbes({
+        body: {
+          skip: 10,
+          limit: 25,
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          skip: new PositiveNumber(10),
+          limit: new PositiveNumber(25),
+        }),
+      );
+    });
+
+    it("should prefer the query string over the body", async () => {
+      await callGlobalProbes({
+        body: {
+          skip: 10,
+          limit: 25,
+        },
+        query: {
+          skip: "30",
+          limit: "40",
+        },
+      });
+
+      expect(ProbeService.findBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          skip: new PositiveNumber(30),
+          limit: new PositiveNumber(40),
+        }),
+      );
+    });
+
+    it("should reject a limit above the per project maximum", async () => {
+      await callGlobalProbes({
+        body: {
+          limit: 10001,
+        },
+      });
+
+      expect(ProbeService.findBy).not.toHaveBeenCalled();
+      expect(nextFunction).toHaveBeenCalledWith(
+        expect.any(BadRequestException),
+      );
+    });
+  });
+
+  describe("count", () => {
+    it("should return the real count rather than the size of the page", async () => {
+      const mockProbes: Array<Probe> = [{ id: "probe" } as unknown as Probe];
+      ProbeService.findBy = jest.fn().mockResolvedValue(mockProbes);
+      ProbeService.countBy = jest
+        .fn()
+        .mockResolvedValue(new PositiveNumber(137));
+
+      const request: ExpressRequest = await callGlobalProbes({
+        query: {
+          limit: "1",
+        },
+      });
+
+      expect(ProbeService.countBy).toHaveBeenCalledWith({
+        query: {
+          isGlobalProbe: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      const response: jest.SpyInstance = jest.spyOn(
+        Response,
+        "sendEntityArrayResponse",
+      );
+      expect(response).toHaveBeenCalledWith(
+        request,
+        mockResponse,
+        mockProbes,
+        new PositiveNumber(137),
+        Probe,
+      );
+    });
+
+    it("should count against the same filtered query the list used", async () => {
+      await callGlobalProbes({
+        body: {
+          query: {
+            name: "probe-1",
+          },
+        },
+      });
+
+      expect(ProbeService.countBy).toHaveBeenCalledWith({
+        query: {
+          name: "probe-1",
+          isGlobalProbe: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    });
   });
 
   it("should call next with an error if findBy throws", async () => {
     const testError: Error = new Error("Test error");
     ProbeService.findBy = jest.fn().mockRejectedValue(testError);
-    await mockRouter
-      .match("post", "/probe/global-probes")
-      .handlerFunction(mockRequest, mockResponse, nextFunction);
-    expect(nextFunction).toHaveBeenCalledWith(testError);
-  });
 
-  afterEach(() => {
-    jest.restoreAllMocks();
+    await callGlobalProbes();
+
+    expect(nextFunction).toHaveBeenCalledWith(testError);
   });
 });