@oneuptime/common 13.0.7 → 14.0.0

package/Tests/Server/Utils/Monitor/MonitoringIntervalValidator.test.ts

@@ -0,0 +1,188 @@
+import MonitoringIntervalValidator from "../../../../Server/Utils/Monitor/MonitoringIntervalValidator";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * WHAT THIS FILE IS DEFENDING
+ *
+ * The write-time policy for Monitor.monitoringInterval. The column was free
+ * text with no validation at all, which is how 103 monitors across 10
+ * projects ended up holding a human cadence ("5m", "Every 5 minutes") that
+ * the scheduler could not read — and silently probed four times too often.
+ *
+ * The policy has to hold two lines at once:
+ *   - refuse values nobody can act on, so the column stops accumulating them;
+ *   - never refuse a value the RUNTIME parser would happily have scheduled,
+ *     because a validator that disagrees with the scheduler is this same bug
+ *     in mirror image.
+ */
+
+describe("MonitoringIntervalValidator.validateAndNormalize", () => {
+  describe("canonicalizes what it understands", () => {
+    test.each([
+      ["5m", "*/5 * * * *"],
+      ["Every 5 minutes", "*/5 * * * *"],
+      ["Every 5 Minutes", "*/5 * * * *"],
+      ["Every Five Minutes", "*/5 * * * *"],
+      ["1 minute", "* * * * *"],
+      ["Every 1 minute", "* * * * *"],
+      ["Every 2 minutes", "*/2 * * * *"],
+      ["5 minutes", "*/5 * * * *"],
+      ["1 day", "0 0 * * *"],
+      ["every-1-min", "* * * * *"],
+    ])("%j is stored as %j", (input: string, expected: string) => {
+      expect(MonitoringIntervalValidator.validateAndNormalize(input)).toBe(
+        expected,
+      );
+    });
+
+    test("already-canonical cron is stored byte-identical", () => {
+      for (const cron of [
+        "* * * * *",
+        "*/5 * * * *",
+        "0 */6 * * *",
+        "0 0 * * 0",
+      ]) {
+        expect(MonitoringIntervalValidator.validateAndNormalize(cron)).toBe(
+          cron,
+        );
+      }
+    });
+  });
+
+  describe("empty means no schedule, and is always legal", () => {
+    /*
+     * A Manual monitor is never probed. ~4,177 production rows are in this
+     * state and must not start throwing on an unrelated edit.
+     */
+    test.each([null, undefined, "", "   "])(
+      "%j is accepted and stored as null",
+      (value: string | null | undefined) => {
+        expect(
+          MonitoringIntervalValidator.validateAndNormalize(value),
+        ).toBeNull();
+      },
+    );
+  });
+
+  describe("never refuses what the scheduler could run", () => {
+    test("accepts a cron-parser shortcut the isomorphic grammar does not know", () => {
+      /*
+       * The isomorphic normalizer reports "@hourly" as Unrecognized, but
+       * cron-parser — the thing that actually computes nextPingAt — reads it
+       * fine. The validator must defer to the runtime parser, and must pass
+       * the value through UNCHANGED rather than rewriting it.
+       */
+      expect(MonitoringIntervalValidator.validateAndNormalize("@hourly")).toBe(
+        "@hourly",
+      );
+    });
+
+    test.each(["@daily", "@weekly", "@monthly", "@yearly"])(
+      "accepts %j unchanged",
+      (shortcut: string) => {
+        expect(MonitoringIntervalValidator.validateAndNormalize(shortcut)).toBe(
+          shortcut,
+        );
+      },
+    );
+
+    test("accepts exotic but valid cron", () => {
+      for (const cron of [
+        "3-59/5 * * * *",
+        "0,15,30,45 * * * *",
+        "0 9 * * 1-5",
+      ]) {
+        expect(MonitoringIntervalValidator.validateAndNormalize(cron)).toBe(
+          cron,
+        );
+      }
+    });
+  });
+
+  describe("refuses what it cannot honour", () => {
+    test.each(["banana", "asap", "soon", "not a cron", "every 7 minutes"])(
+      "%j throws BadDataException",
+      (input: string) => {
+        expect(() => {
+          return MonitoringIntervalValidator.validateAndNormalize(input);
+        }).toThrow(BadDataException);
+      },
+    );
+
+    test("the error message names a cron the caller can copy", () => {
+      /*
+       * The whole reason these rows exist is that we never told anyone what
+       * this field wanted. An error that only says "invalid" repeats the
+       * mistake.
+       */
+      let message: string = "";
+
+      try {
+        MonitoringIntervalValidator.validateAndNormalize("banana");
+      } catch (err) {
+        message = (err as BadDataException).message;
+      }
+
+      expect(message).toContain("banana");
+      expect(message).toContain("*/5 * * * *");
+      expect(message.toLowerCase()).toContain("cron");
+    });
+
+    test("refuses a sub-minute schedule the probe fleet cannot deliver", () => {
+      /*
+       * cron-parser accepts 6-field per-second expressions. Without an
+       * explicit floor an API client would ask for a per-second probe and
+       * silently receive a per-minute one — the exact shape of the bug this
+       * file exists to close, just in the other direction.
+       */
+      expect(() => {
+        return MonitoringIntervalValidator.validateAndNormalize("* * * * * *");
+      }).toThrow(BadDataException);
+
+      expect(() => {
+        return MonitoringIntervalValidator.validateAndNormalize(
+          "*/30 * * * * *",
+        );
+      }).toThrow(BadDataException);
+    });
+
+    test("the fastest supported schedule is still accepted", () => {
+      expect(
+        MonitoringIntervalValidator.validateAndNormalize("* * * * *"),
+      ).toBe("* * * * *");
+    });
+  });
+
+  describe("idempotence", () => {
+    test("validating a stored value again changes nothing", () => {
+      for (const input of [
+        "5m",
+        "Every 5 minutes",
+        "1 day",
+        "*/5 * * * *",
+        "@hourly",
+      ]) {
+        const once: string | null =
+          MonitoringIntervalValidator.validateAndNormalize(input);
+        expect(MonitoringIntervalValidator.validateAndNormalize(once)).toBe(
+          once,
+        );
+      }
+    });
+  });
+
+  describe("normalizeForRead", () => {
+    test("is total — a row written before this validator existed is not an exception", () => {
+      expect(MonitoringIntervalValidator.normalizeForRead("5m")).toBe(
+        "*/5 * * * *",
+      );
+      expect(MonitoringIntervalValidator.normalizeForRead("banana")).toBeNull();
+      expect(MonitoringIntervalValidator.normalizeForRead(null)).toBeNull();
+
+      expect(() => {
+        return MonitoringIntervalValidator.normalizeForRead("🙂");
+      }).not.toThrow();
+    });
+  });
+});

package/Tests/Server/Utils/Realtime.test.ts

@@ -0,0 +1,502 @@
+import IO, { Socket } from "../../../Server/Infrastructure/SocketIO";
+import { EncryptionSecret } from "../../../Server/EnvironmentConfig";
+import CookieUtil from "../../../Server/Utils/Cookie";
+import JSONWebToken from "../../../Server/Utils/JsonWebToken";
+import Realtime, {
+  ListenToModelEventOutcome,
+} from "../../../Server/Utils/Realtime";
+import UserPermissionUtil from "../../../Server/Utils/UserPermission/UserPermission";
+import DatabaseType from "../../../Types/BaseDatabase/DatabaseType";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import {
+  UserGlobalAccessPermission,
+  UserTenantAccessPermission,
+} from "../../../Types/Permission";
+import EventName from "../../../Types/Realtime/EventName";
+import ListenToModelEventJSON from "../../../Types/Realtime/ListenToModelEventJSON";
+import ModelEventType from "../../../Types/Realtime/ModelEventType";
+import RealtimeUtil from "../../../Utils/Realtime";
+import {
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "@jest/globals";
+import jwt from "jsonwebtoken";
+
+/*
+ * Contract under test - what the server does with a ListenToModelEvent whose
+ * socket has no usable session.
+ *
+ * Each subscription is authorized with the access-token cookie from the
+ * socket's HANDSHAKE, which is not re-read for the life of the connection. The
+ * dashboard's access token lives 15 minutes, so a tab left open longer sends
+ * every new subscription on a socket whose token no longer decodes. The decode
+ * used to throw inside the async socket listener: an unhandled rejection, no
+ * room joined, and nothing sent back, so the client could not know it had to
+ * refresh and reconnect.
+ *
+ * Now a missing or expired token is answered with EventName.AuthenticationRequired
+ * (carrying the refused subscription), nothing escapes the listener, and an
+ * authorized subscription joins its room exactly as before.
+ */
+
+jest.mock("../../../Server/Infrastructure/SocketIO", () => {
+  return {
+    __esModule: true,
+    default: {
+      getSocketServer: jest.fn(),
+    },
+  };
+});
+
+jest.mock("../../../Server/Utils/UserPermission/UserPermission", () => {
+  return {
+    __esModule: true,
+    default: {
+      getUserGlobalAccessPermissionFromCache: jest.fn(),
+      getUserTenantAccessPermissionFromCache: jest.fn(),
+    },
+  };
+});
+
+// Model permissions are looked up by name; the tests stub that lookup instead.
+jest.mock("../../../Models/DatabaseModels/Index", () => {
+  return {
+    __esModule: true,
+    default: [],
+    getModelTypeByName: (): null => {
+      return null;
+    },
+  };
+});
+
+jest.mock("../../../Models/AnalyticsModels/Index", () => {
+  return {
+    __esModule: true,
+    default: [],
+    getModelTypeByName: (): null => {
+      return null;
+    },
+  };
+});
+
+type Listener = (...args: Array<unknown>) => unknown;
+
+interface EmittedEvent {
+  event: string;
+  data: unknown;
+}
+
+// Just enough of a server-side socket.io Socket.
+class FakeServerSocket {
+  public handshake: { headers: { cookie?: string | undefined } };
+  public emitted: Array<EmittedEvent> = [];
+  public joinedRooms: Array<string> = [];
+  public listeners: Map<string, Listener> = new Map();
+
+  public constructor(cookie?: string) {
+    this.handshake = { headers: { cookie: cookie } };
+  }
+
+  public on(event: string, listener: Listener): FakeServerSocket {
+    this.listeners.set(event, listener);
+    return this;
+  }
+
+  public emit(event: string, data: unknown): boolean {
+    this.emitted.push({ event: event, data: data });
+    return true;
+  }
+
+  public async join(roomId: string): Promise<void> {
+    this.joinedRooms.push(roomId);
+  }
+
+  public asSocket(): Socket {
+    return this as unknown as Socket;
+  }
+
+  public authenticationRequiredEvents(): Array<unknown> {
+    return this.emitted
+      .filter((emitted: EmittedEvent) => {
+        return emitted.event === EventName.AuthenticationRequired;
+      })
+      .map((emitted: EmittedEvent) => {
+        return emitted.data;
+      });
+  }
+}
+
+const TENANT_ID: string = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+const OTHER_TENANT_ID: string = "cccccccc-cccc-4ccc-8ccc-cccccccccccc";
+const USER_ID: string = "dddddddd-dddd-4ddd-8ddd-dddddddddddd";
+
+const REQUEST: ListenToModelEventJSON = {
+  eventType: ModelEventType.Create,
+  modelType: DatabaseType.Database,
+  modelName: "Incident",
+  tenantId: TENANT_ID,
+};
+
+const ROOM_ID: string = RealtimeUtil.getRoomId(
+  TENANT_ID,
+  "Incident",
+  ModelEventType.Create,
+);
+
+type TokenFunction = (claims?: JSONObject) => string;
+
+const validToken: TokenFunction = (claims: JSONObject = {}): string => {
+  return JSONWebToken.signJsonPayload(
+    {
+      userId: USER_ID,
+      email: "realtime-test@oneuptime.com",
+      name: "Realtime Test",
+      isMasterAdmin: false,
+      ...claims,
+    },
+    15 * 60,
+  );
+};
+
+const expiredToken: TokenFunction = (): string => {
+  return jwt.sign(
+    {
+      userId: USER_ID,
+      email: "realtime-test@oneuptime.com",
+      name: "Realtime Test",
+      isMasterAdmin: false,
+      exp: Math.floor(Date.now() / 1000) - 60,
+    },
+    EncryptionSecret.toString(),
+  );
+};
+
+type CookieFunction = (token: string) => string;
+
+const cookieWith: CookieFunction = (token: string): string => {
+  return `some-other-cookie=1; ${CookieUtil.getUserTokenKey()}=${token}`;
+};
+
+const getGlobalPermission: jest.Mock =
+  UserPermissionUtil.getUserGlobalAccessPermissionFromCache as unknown as jest.Mock;
+const getTenantPermission: jest.Mock =
+  UserPermissionUtil.getUserTenantAccessPermissionFromCache as unknown as jest.Mock;
+
+type MemberOfFunction = (projectIds: Array<string>) => void;
+
+const memberOf: MemberOfFunction = (projectIds: Array<string>): void => {
+  getGlobalPermission.mockResolvedValue({
+    projectIds: projectIds.map((projectId: string) => {
+      return new ObjectID(projectId);
+    }),
+    globalPermissions: [],
+    isMasterAdmin: false,
+    _type: "UserGlobalAccessPermission",
+  } as unknown as UserGlobalAccessPermission);
+
+  getTenantPermission.mockResolvedValue({
+    projectId: new ObjectID(TENANT_ID),
+    permissions: [],
+    isBlockPermissionsEnabled: false,
+    _type: "UserTenantAccessPermission",
+  } as unknown as UserTenantAccessPermission);
+};
+
+describe("Realtime (server) ListenToModelEvent", () => {
+  let connectionListener: (socket: Socket) => void = (): void => {};
+
+  beforeAll(async () => {
+    (IO.getSocketServer as unknown as jest.Mock).mockReturnValue({
+      on: (event: string, listener: (socket: Socket) => void): void => {
+        if (event === "connection") {
+          connectionListener = listener;
+        }
+      },
+    });
+
+    await Realtime.init();
+  });
+
+  beforeEach(() => {
+    getGlobalPermission.mockReset();
+    getTenantPermission.mockReset();
+    getGlobalPermission.mockResolvedValue(null);
+    getTenantPermission.mockResolvedValue(null);
+    jest.spyOn(Realtime, "hasPermissionsByModelName").mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("a socket without a usable session", () => {
+    test("no access-token cookie in the handshake: no room, and the client is told authentication is required", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket();
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.AuthenticationRequired);
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.authenticationRequiredEvents()).toEqual([REQUEST]);
+    });
+
+    test("a cookie header without the access token counts as no token", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket(
+        "some-other-cookie=1",
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.AuthenticationRequired);
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.authenticationRequiredEvents()).toEqual([REQUEST]);
+    });
+
+    test("an expired access token (a tab open past 15 minutes): the decode failure does not escape, no room, client told", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(expiredToken()),
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.AuthenticationRequired);
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.authenticationRequiredEvents()).toEqual([REQUEST]);
+      expect(getGlobalPermission).not.toHaveBeenCalled();
+    });
+
+    test("a token that is not a JWT at all is treated the same way", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith("not-a-jwt"),
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.AuthenticationRequired);
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.authenticationRequiredEvents()).toEqual([REQUEST]);
+    });
+
+    test("listenToModelEvent itself reports the outcome and signals the client", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(expiredToken()),
+      );
+
+      await expect(
+        Realtime.listenToModelEvent(socket.asSocket(), REQUEST),
+      ).resolves.toBe(ListenToModelEventOutcome.AuthenticationRequired);
+
+      expect(socket.authenticationRequiredEvents()).toEqual([REQUEST]);
+    });
+  });
+
+  describe("the socket listener", () => {
+    type FlushFunction = () => Promise<void>;
+
+    const flush: FlushFunction = async (): Promise<void> => {
+      for (let i: number = 0; i < 5; i++) {
+        await new Promise<void>((resolve: () => void) => {
+          setTimeout(resolve, 0);
+        });
+      }
+    };
+
+    type ListenerForFunction = (socket: FakeServerSocket) => Listener;
+
+    const listenerFor: ListenerForFunction = (
+      socket: FakeServerSocket,
+    ): Listener => {
+      connectionListener(socket.asSocket());
+
+      const listener: Listener | undefined = socket.listeners.get(
+        EventName.ListenToModalEvent,
+      );
+
+      expect(listener).toBeDefined();
+
+      return listener!;
+    };
+
+    /*
+     * socket.io discards what a listener returns. The old listener was async,
+     * so an expired token made it return a promise that rejected, and nobody
+     * was listening for that rejection.
+     */
+    test("an expired token: the listener hands socket.io nothing that can reject, and the client is told", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(expiredToken()),
+      );
+
+      const returned: unknown = listenerFor(socket)(REQUEST);
+
+      await expect(Promise.resolve(returned)).resolves.toBeUndefined();
+
+      await flush();
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.authenticationRequiredEvents()).toEqual([REQUEST]);
+    });
+
+    test("a malformed request is refused without a rejection and without an authentication signal", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(validToken()),
+      );
+
+      const returned: unknown = listenerFor(socket)({
+        ...REQUEST,
+        eventType: 42,
+      });
+
+      await expect(Promise.resolve(returned)).resolves.toBeUndefined();
+
+      await flush();
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.emitted).toEqual([]);
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          undefined as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.InvalidRequest);
+    });
+
+    test("a valid session joins the room through the listener", async () => {
+      memberOf([TENANT_ID]);
+
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(validToken()),
+      );
+
+      listenerFor(socket)(REQUEST);
+
+      await flush();
+
+      expect(socket.joinedRooms).toEqual([ROOM_ID]);
+      expect(socket.emitted).toEqual([]);
+    });
+  });
+
+  describe("a socket with a valid session (unchanged)", () => {
+    test("a project member with read permission joins the room, and nothing is sent back", async () => {
+      memberOf([TENANT_ID]);
+
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(validToken()),
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.Joined);
+
+      expect(socket.joinedRooms).toEqual([ROOM_ID]);
+      expect(socket.emitted).toEqual([]);
+      expect(Realtime.hasPermissionsByModelName).toHaveBeenCalledWith(
+        expect.anything(),
+        "Incident",
+      );
+    });
+
+    test("a master admin joins the room", async () => {
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(validToken({ isMasterAdmin: true })),
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.Joined);
+
+      expect(socket.joinedRooms).toEqual([ROOM_ID]);
+    });
+
+    /*
+     * Authorization-denied keeps its old behaviour: no room and no message. A
+     * fresh session would not change the answer, so the client must not be
+     * sent into a refresh-and-reconnect for it.
+     */
+    test("not a member of the project: no room, and no authentication signal", async () => {
+      memberOf([OTHER_TENANT_ID]);
+
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(validToken()),
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.NotAuthorized);
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.emitted).toEqual([]);
+    });
+
+    test("a member without read permission on the model: no room, and no authentication signal", async () => {
+      memberOf([TENANT_ID]);
+      (
+        Realtime.hasPermissionsByModelName as unknown as jest.Mock
+      ).mockReturnValue(false);
+
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(validToken()),
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.NotAuthorized);
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.emitted).toEqual([]);
+    });
+
+    test("a failing permission lookup (the cache is down) is contained: no room, no signal, no rejection", async () => {
+      getGlobalPermission.mockRejectedValue(new Error("Redis is down"));
+
+      const socket: FakeServerSocket = new FakeServerSocket(
+        cookieWith(validToken()),
+      );
+
+      await expect(
+        Realtime.handleListenToModelEventRequest(
+          socket.asSocket(),
+          REQUEST as unknown as JSONObject,
+        ),
+      ).resolves.toBe(ListenToModelEventOutcome.Failed);
+
+      expect(socket.joinedRooms).toEqual([]);
+      expect(socket.emitted).toEqual([]);
+    });
+  });
+});