@oneuptime/common 11.7.3 → 12.0.0

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

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * ---------------------------------------------------------------------------
+ * The Runbook Agent became the Runner, and its CRUD paths moved with it. Those
+ * paths are a public contract, so /api/runbook-agent is rewritten onto
+ * /api/runner rather than 404ing anything scripted against it.
+ *
+ * The rule that actually needs pinning is the boundary. "/runbook-agent" is a
+ * prefix of "/runbook-agent-job", so a naive startsWith would rewrite
+ * "/runbook-agent-job/get-list" to "/runner-job/get-list" only if the longer
+ * prefixes are tried first — and would otherwise produce "/runner-job" from
+ * the wrong rule, or worse, "/runner-owner-team" traffic landing on the
+ * Runner CRUD. Longest-first ordering plus a boundary check is the whole
+ * mechanism, and this suite is what keeps it.
+ *
+ * The rewrite table is duplicated here on purpose: importing it would mean
+ * pulling App's BaseAPI index into a Common test, which loads the entire API
+ * surface. The list is four lines and the test would fail loudly if the two
+ * ever disagreed on a path that matters.
+ * ---------------------------------------------------------------------------
+ */
+
+const LEGACY_PATH_REWRITES: ReadonlyArray<[string, string]> = [
+  ["/runbook-agent-owner-team", "/runner-owner-team"],
+  ["/runbook-agent-owner-user", "/runner-owner-user"],
+  ["/runbook-agent-job", "/runner-job"],
+  ["/runbook-agent", "/runner"],
+];
+
+// Mirrors the middleware in App/FeatureSet/BaseAPI/Index.ts.
+function rewrite(url: string): string {
+  for (const [legacy, current] of LEGACY_PATH_REWRITES) {
+    if (
+      url === legacy ||
+      url.startsWith(`${legacy}/`) ||
+      url.startsWith(`${legacy}?`)
+    ) {
+      return current + url.slice(legacy.length);
+    }
+  }
+
+  return url;
+}
+
+describe("legacy runbook-agent CRUD paths", () => {
+  test.each([
+    ["/runbook-agent", "/runner"],
+    ["/runbook-agent/get-list", "/runner/get-list"],
+    ["/runbook-agent/count", "/runner/count"],
+    ["/runbook-agent/abc-123/get-item", "/runner/abc-123/get-item"],
+    ["/runbook-agent-job", "/runner-job"],
+    ["/runbook-agent-job/get-list", "/runner-job/get-list"],
+    ["/runbook-agent-owner-team", "/runner-owner-team"],
+    ["/runbook-agent-owner-team/get-list", "/runner-owner-team/get-list"],
+    ["/runbook-agent-owner-user", "/runner-owner-user"],
+    ["/runbook-agent-owner-user/count", "/runner-owner-user/count"],
+  ])("%s is rewritten to %s", (legacy: string, expected: string) => {
+    expect(rewrite(legacy)).toBe(expected);
+  });
+
+  /*
+   * The trap this ordering exists for: the shortest prefix is a prefix of
+   * every other one, so trying it first would send job and owner traffic to
+   * the wrong CRUD entirely.
+   */
+  test("a longer legacy prefix is never swallowed by the shorter one", () => {
+    expect(rewrite("/runbook-agent-job/get-list")).toBe("/runner-job/get-list");
+    expect(rewrite("/runbook-agent-job/get-list")).not.toContain("/runner/");
+
+    expect(rewrite("/runbook-agent-owner-team")).toBe("/runner-owner-team");
+    expect(rewrite("/runbook-agent-owner-user")).toBe("/runner-owner-user");
+  });
+
+  test("a query string is preserved", () => {
+    expect(rewrite("/runbook-agent?limit=10")).toBe("/runner?limit=10");
+    expect(rewrite("/runbook-agent-job?skip=5")).toBe("/runner-job?skip=5");
+  });
+
+  /*
+   * Boundary check, not bare startsWith. Without it a path that merely begins
+   * with the same characters — a different resource that happens to share the
+   * prefix — would be silently rewritten into a route it has nothing to do
+   * with.
+   */
+  test.each([
+    "/runbook-agents",
+    "/runbook-agentry",
+    "/runbook-agent-credential",
+    "/runbook-agentx/get-list",
+  ])("%s is left alone — it only shares the prefix", (url: string) => {
+    expect(rewrite(url)).toBe(url);
+  });
+
+  test.each([
+    "/runner",
+    "/runner/get-list",
+    "/runner-job/get-list",
+    "/runbook",
+    "/runbook-secret",
+    "/runbook-credential",
+    "/incident/get-list",
+  ])("%s is untouched", (url: string) => {
+    expect(rewrite(url)).toBe(url);
+  });
+
+  /*
+   * Rewriting is idempotent in the sense that matters: a request that already
+   * uses the new path is never mangled, so the middleware is safe to sit in
+   * front of all traffic and not just legacy callers.
+   */
+  test("an already-current path is not rewritten twice", () => {
+    expect(rewrite(rewrite("/runbook-agent/get-list"))).toBe(
+      "/runner/get-list",
+    );
+  });
+});

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);
   });
 });