@oneuptime/common 12.0.33 → 13.0.0

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

@@ -0,0 +1,329 @@
+import RoutineEmailSettingsService from "../../../Server/Services/RoutineEmailSettingsService";
+import UserNotificationSettingService from "../../../Server/Services/UserNotificationSettingService";
+import PostgresAppInstance from "../../../Server/Infrastructure/PostgresDatabase";
+import Entities from "../../../Models/DatabaseModels/Index";
+import NotificationSettingEventType from "../../../Types/NotificationSetting/NotificationSettingEventType";
+import { ROUTINE_EMAIL_EVENT_TYPES } from "../../../Types/NotificationSetting/RoutineEmailEvents";
+import ObjectID from "../../../Types/ObjectID";
+import { DataSource } from "typeorm";
+
+/*
+ * Opt in with RUN_POSTGRES_NOTIFICATION_TESTS=true and the normal database
+ * credentials. Uses the local development Postgres port unless overridden by
+ * NOTIFICATION_TEST_DATABASE_HOST / NOTIFICATION_TEST_DATABASE_PORT.
+ * All writes go to a uniquely named schema; no project data is modified.
+ * Cloning the production table also verifies the statements against its actual
+ * defaults and column types rather than a hand-maintained test schema.
+ */
+const describePostgres: typeof describe =
+  process.env["RUN_POSTGRES_NOTIFICATION_TESTS"] === "true"
+    ? describe
+    : describe.skip;
+
+const USER_ID: ObjectID = ObjectID.generate();
+const OTHER_USER_ID: ObjectID = ObjectID.generate();
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const OTHER_PROJECT_ID: ObjectID = ObjectID.generate();
+const ROUTINE_EVENT: NotificationSettingEventType =
+  NotificationSettingEventType.SEND_INCIDENT_NOTE_POSTED_OWNER_NOTIFICATION;
+const CHANNELS: Array<string> = [
+  "alertBySMS",
+  "alertByCall",
+  "alertByPush",
+  "alertByWhatsApp",
+  "alertByTelegram",
+  "alertBySlack",
+  "alertByMicrosoftTeams",
+  "alertByWebhook",
+];
+
+interface StoredSetting {
+  _id: string;
+  userId: string;
+  projectId: string;
+  eventType: NotificationSettingEventType;
+  alertByEmail: boolean;
+  version: number;
+  deletedAt: Date | null;
+  [key: string]: unknown;
+}
+
+describePostgres("reduce routine emails against Postgres", () => {
+  const schema: string = `routine_email_test_${ObjectID.generate().toString().replace(/-/g, "")}`;
+  let database: DataSource;
+
+  beforeAll(async () => {
+    database = new DataSource({
+      type: "postgres",
+      host: process.env["NOTIFICATION_TEST_DATABASE_HOST"] || "localhost",
+      port: Number(process.env["NOTIFICATION_TEST_DATABASE_PORT"] || "5400"),
+      username: process.env["DATABASE_USERNAME"] || "postgres",
+      password: process.env["DATABASE_PASSWORD"] || "password",
+      database: process.env["DATABASE_NAME"] || "oneuptimedb",
+      entities: Entities,
+      schema: schema,
+      synchronize: false,
+      extra: { options: `-c search_path=${schema},public` },
+    });
+    await database.initialize();
+    await database.query(`CREATE SCHEMA "${schema}"`);
+    await database.query(
+      `CREATE TABLE "${schema}"."UserNotificationSetting" (LIKE public."UserNotificationSetting" INCLUDING ALL)`,
+    );
+    const currentSchema: Array<{ current_schema: string }> =
+      await database.query("SELECT current_schema()");
+    expect(currentSchema[0]?.current_schema).toBe(schema);
+    jest.spyOn(PostgresAppInstance, "isConnected").mockReturnValue(true);
+    jest.spyOn(PostgresAppInstance, "getDataSource").mockReturnValue(database);
+  });
+
+  beforeEach(async () => {
+    await database.query(`TRUNCATE "${schema}"."UserNotificationSetting"`);
+  });
+
+  afterAll(async () => {
+    jest.restoreAllMocks();
+    if (database?.isInitialized) {
+      await database.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await database.destroy();
+    }
+  });
+
+  async function seed(data: {
+    eventType: NotificationSettingEventType;
+    email?: boolean;
+    userId?: ObjectID;
+    projectId?: ObjectID;
+    deleted?: boolean;
+  }): Promise<StoredSetting> {
+    const rows: Array<StoredSetting> = await database.query(
+      `INSERT INTO "UserNotificationSetting"
+       ("userId", "projectId", "eventType", "alertByEmail", "version", "deletedAt", ${CHANNELS.map(
+         (channel: string) => {
+           return `"${channel}"`;
+         },
+       ).join(", ")})
+       VALUES ($1, $2, $3, $4, 1, $5, ${CHANNELS.map(() => {
+         return "true";
+       }).join(", ")})
+       RETURNING *`,
+      [
+        (data.userId || USER_ID).toString(),
+        (data.projectId || PROJECT_ID).toString(),
+        data.eventType,
+        data.email ?? true,
+        data.deleted ? new Date() : null,
+      ],
+    );
+    return rows[0]!;
+  }
+
+  async function rows(): Promise<Array<StoredSetting>> {
+    return await database.query(
+      'SELECT * FROM "UserNotificationSetting" ORDER BY "_id"',
+    );
+  }
+
+  async function apply(): Promise<void> {
+    await RoutineEmailSettingsService.reduceRoutineEmails({
+      userId: USER_ID,
+      projectId: PROJECT_ID,
+    });
+  }
+
+  test("creates a persisted opt-out for every missing routine event", async () => {
+    await apply();
+    const settings: Array<StoredSetting> = await rows();
+    expect(settings).toHaveLength(ROUTINE_EMAIL_EVENT_TYPES.length);
+    expect(
+      new Set(
+        settings.map((setting: StoredSetting) => {
+          return setting.eventType;
+        }),
+      ),
+    ).toEqual(new Set(ROUTINE_EMAIL_EVENT_TYPES));
+    for (const setting of settings) {
+      expect(setting.userId).toBe(USER_ID.toString());
+      expect(setting.projectId).toBe(PROJECT_ID.toString());
+      expect(setting["createdByUserId"]).toBe(USER_ID.toString());
+      expect(setting.alertByEmail).toBe(false);
+      expect(setting.version).toBe(1);
+      for (const channel of CHANNELS) {
+        expect(setting[channel]).toBe(false);
+      }
+    }
+  });
+
+  test("disables only email while preserving every other channel on existing rows", async () => {
+    for (const eventType of ROUTINE_EMAIL_EVENT_TYPES) {
+      await seed({ eventType });
+    }
+    await apply();
+    const settings: Array<StoredSetting> = await rows();
+    expect(settings).toHaveLength(ROUTINE_EMAIL_EVENT_TYPES.length);
+    for (const setting of settings) {
+      expect(setting.alertByEmail).toBe(false);
+      expect(setting.version).toBe(2);
+      for (const channel of CHANNELS) {
+        expect(setting[channel]).toBe(true);
+      }
+    }
+  });
+
+  test("preserves every non-routine event, including existing opt-outs", async () => {
+    const preserved: Array<StoredSetting> = [];
+    for (const eventType of Object.values(NotificationSettingEventType)) {
+      if (!ROUTINE_EMAIL_EVENT_TYPES.includes(eventType)) {
+        preserved.push(await seed({ eventType }));
+        preserved.push(await seed({ eventType, email: false }));
+      }
+    }
+    await apply();
+    const settings: Array<StoredSetting> = await rows();
+    for (const before of preserved) {
+      expect(
+        settings.find((setting: StoredSetting) => {
+          return setting._id === before._id;
+        }),
+      ).toEqual(before);
+    }
+  });
+
+  test("does not create missing incident, alert or on-call preferences", async () => {
+    await apply();
+    for (const setting of await rows()) {
+      expect(ROUTINE_EMAIL_EVENT_TYPES).toContain(setting.eventType);
+    }
+  });
+
+  test("preserves an event introduced after this preset was defined", async () => {
+    const futureEvent: StoredSetting = await seed({
+      eventType: "Future notification event" as NotificationSettingEventType,
+    });
+    await apply();
+    expect(
+      (await rows()).find((setting: StoredSetting) => {
+        return setting._id === futureEvent._id;
+      }),
+    ).toEqual(futureEvent);
+  });
+
+  test("leaves other users and projects unchanged", async () => {
+    const preserved: Array<StoredSetting> = [
+      await seed({ eventType: ROUTINE_EVENT, userId: OTHER_USER_ID }),
+      await seed({ eventType: ROUTINE_EVENT, projectId: OTHER_PROJECT_ID }),
+      await seed({
+        eventType: ROUTINE_EVENT,
+        userId: OTHER_USER_ID,
+        projectId: OTHER_PROJECT_ID,
+      }),
+    ];
+    await apply();
+    const settings: Array<StoredSetting> = await rows();
+    for (const before of preserved) {
+      expect(
+        settings.find((setting: StoredSetting) => {
+          return setting._id === before._id;
+        }),
+      ).toEqual(before);
+    }
+  });
+
+  test("repeated requests do not create duplicates or change row versions and timestamps", async () => {
+    await seed({ eventType: ROUTINE_EVENT });
+    await apply();
+    const first: Array<StoredSetting> = await rows();
+    await apply();
+    expect(await rows()).toEqual(first);
+  });
+
+  test("later default seeding respects every persisted opt-out", async () => {
+    await apply();
+    const before: Array<StoredSetting> = await rows();
+    for (const eventType of ROUTINE_EMAIL_EVENT_TYPES) {
+      await UserNotificationSettingService.ensureSettingExistsForUser({
+        userId: USER_ID,
+        projectId: PROJECT_ID,
+        eventType: eventType,
+      });
+    }
+    expect(await rows()).toEqual(before);
+  });
+
+  test("simultaneous requests create only one live row per routine event", async () => {
+    await Promise.all(
+      Array.from({ length: 8 }, async () => {
+        return apply();
+      }),
+    );
+    const settings: Array<StoredSetting> = await rows();
+    expect(settings).toHaveLength(ROUTINE_EMAIL_EVENT_TYPES.length);
+    expect(
+      new Set(
+        settings.map((setting: StoredSetting) => {
+          return setting.eventType;
+        }),
+      ).size,
+    ).toBe(ROUTINE_EMAIL_EVENT_TYPES.length);
+    expect(
+      settings.every((setting: StoredSetting) => {
+        return setting.alertByEmail === false;
+      }),
+    ).toBe(true);
+  });
+
+  test("disables all live historical duplicates for the same event", async () => {
+    const first: StoredSetting = await seed({ eventType: ROUTINE_EVENT });
+    const second: StoredSetting = await seed({ eventType: ROUTINE_EVENT });
+    await apply();
+    const settings: Array<StoredSetting> = await rows();
+    for (const id of [first._id, second._id]) {
+      expect(
+        settings.find((setting: StoredSetting) => {
+          return setting._id === id;
+        })?.alertByEmail,
+      ).toBe(false);
+    }
+    expect(settings).toHaveLength(ROUTINE_EMAIL_EVENT_TYPES.length + 1);
+  });
+
+  test("retains deleted history and creates a new live opt-out", async () => {
+    const deleted: StoredSetting = await seed({
+      eventType: ROUTINE_EVENT,
+      deleted: true,
+    });
+    await apply();
+    const settings: Array<StoredSetting> = await rows();
+    expect(
+      settings.find((setting: StoredSetting) => {
+        return setting._id === deleted._id;
+      }),
+    ).toEqual(deleted);
+    expect(
+      settings.filter((setting: StoredSetting) => {
+        return (
+          setting.eventType === ROUTINE_EVENT && setting.deletedAt === null
+        );
+      }),
+    ).toEqual([expect.objectContaining({ alertByEmail: false })]);
+  });
+
+  test("rolls back existing changes when inserting a missing preference fails", async () => {
+    const original: StoredSetting = await seed({ eventType: ROUTINE_EVENT });
+    // A database constraint supplies a real statement failure after UPDATE.
+    await database.query(
+      'ALTER TABLE "UserNotificationSetting" ADD CONSTRAINT "fail_missing_preferences" CHECK ("eventType" = \'Send incident note posted notification when I am the owner of the incident\')',
+    );
+    try {
+      await expect(apply()).rejects.toThrow();
+      expect(await rows()).toEqual([original]);
+    } finally {
+      await database.query(
+        'ALTER TABLE "UserNotificationSetting" DROP CONSTRAINT "fail_missing_preferences"',
+      );
+    }
+    // The failed transaction also releases the advisory lock, so retry works.
+    await apply();
+    expect(await rows()).toHaveLength(ROUTINE_EMAIL_EVENT_TYPES.length);
+  });
+});

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

@@ -0,0 +1,267 @@
+import RumSessionReplayViewService, {
+  SESSION_REPLAY_MAX_SECONDS_WATCHED,
+  SESSION_REPLAY_WATCH_BUCKET_SECONDS,
+  normalizeSecondsWatched,
+} from "../../../Server/Services/RumSessionReplayViewService";
+import RumSessionReplayView from "../../../Models/DatabaseModels/RumSessionReplayView";
+import ColumnLength from "../../../Types/Database/ColumnLength";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import { getJestSpyOn } from "../../Spy";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * The replay read audit. Two properties that the routes cannot pin
+ * because they mock this service whole:
+ *
+ *  1. The audit write must not be failable by its own inputs. Every
+ *     free-text field off the request is truncated to its column, the
+ *     exception fingerprint included: DatabaseService.create throws on an
+ *     over-long value, and an audit insert that throws fails the playback
+ *     it exists to record.
+ *  2. secondsWatched is time WATCHED, monotonic, floored to the heartbeat
+ *     bucket, and advanced by a single guarded UPDATE rather than a
+ *     read-then-write - so two heartbeats racing for the row cannot walk
+ *     it backwards, and a heartbeat that does not advance writes nothing.
+ */
+
+describe("RumSessionReplayViewService", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const rumApplicationId: ObjectID = ObjectID.generate();
+  const userId: ObjectID = ObjectID.generate();
+
+  let createSpy: jest.SpyInstance;
+  let findOneBySpy: jest.SpyInstance;
+  let updateOneBySpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    createSpy = getJestSpyOn(RumSessionReplayViewService, "create");
+    createSpy.mockImplementation(
+      async (createBy: { data: RumSessionReplayView }) => {
+        return createBy.data;
+      },
+    );
+    findOneBySpy = getJestSpyOn(
+      RumSessionReplayViewService,
+      "findOneBy",
+    ).mockResolvedValue(null);
+    updateOneBySpy = getJestSpyOn(
+      RumSessionReplayViewService,
+      "updateOneBy",
+    ).mockResolvedValue(1);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("recordView", () => {
+    test("writes the row as root, names the human, and starts at zero seconds", async () => {
+      const view: RumSessionReplayView =
+        await RumSessionReplayViewService.recordView({
+          projectId: projectId,
+          rumApplicationId: rumApplicationId,
+          sessionId: "s-1",
+          viewedByUserId: userId,
+          accessReason: "incident triage",
+        });
+
+      expect(createSpy).toHaveBeenCalledTimes(1);
+      const createBy: JSONObject = createSpy.mock.calls[0]![0] as JSONObject;
+      expect((createBy["props"] as JSONObject)["isRoot"]).toBe(true);
+
+      expect(view.projectId?.toString()).toBe(projectId.toString());
+      expect(view.rumApplicationId?.toString()).toBe(
+        rumApplicationId.toString(),
+      );
+      expect(view.sessionId).toBe("s-1");
+      expect(view.viewedByUserId?.toString()).toBe(userId.toString());
+      expect(view.createdByUserId?.toString()).toBe(userId.toString());
+      expect(view.secondsWatched).toBe(0);
+      expect(view.viewedAt).toBeInstanceOf(Date);
+      expect(view.accessReason).toBe("incident triage");
+    });
+
+    test("truncates every request-supplied string to its column, the fingerprint included", async () => {
+      const view: RumSessionReplayView =
+        await RumSessionReplayViewService.recordView({
+          projectId: projectId,
+          rumApplicationId: rumApplicationId,
+          sessionId: "s-1",
+          ipAddress: "1".repeat(1000),
+          userAgent: "u".repeat(5000),
+          accessReason: "r".repeat(5000),
+          linkedExceptionFingerprint: "f".repeat(1000),
+        });
+
+      expect(view.ipAddress).toHaveLength(ColumnLength.ShortText);
+      expect(view.userAgent).toHaveLength(ColumnLength.LongText);
+      expect(view.accessReason).toHaveLength(ColumnLength.LongText);
+      expect(view.linkedExceptionFingerprint).toHaveLength(
+        ColumnLength.ShortText,
+      );
+    });
+  });
+
+  describe("findOwnView", () => {
+    test("looks the row up as the caller's own, optionally pinned to a session, and carries the watched figure", async () => {
+      const viewId: ObjectID = ObjectID.generate();
+
+      await RumSessionReplayViewService.findOwnView({
+        viewId: viewId,
+        projectId: projectId,
+        viewedByUserId: userId,
+        sessionId: "s-1",
+      });
+
+      const args: JSONObject = findOneBySpy.mock.calls[0]![0] as JSONObject;
+      const query: JSONObject = args["query"] as JSONObject;
+      const select: JSONObject = args["select"] as JSONObject;
+
+      expect(query["_id"]).toBe(viewId.toString());
+      expect((query["projectId"] as ObjectID).toString()).toBe(
+        projectId.toString(),
+      );
+      expect((query["viewedByUserId"] as ObjectID).toString()).toBe(
+        userId.toString(),
+      );
+      expect(query["sessionId"]).toBe("s-1");
+      expect(select["secondsWatched"]).toBe(true);
+      expect(select["rumApplicationId"]).toBe(true);
+      expect((args["props"] as JSONObject)["isRoot"]).toBe(true);
+    });
+
+    test("omits the session predicate when no session is given", async () => {
+      await RumSessionReplayViewService.findOwnView({
+        viewId: ObjectID.generate(),
+        projectId: projectId,
+        viewedByUserId: userId,
+      });
+
+      const query: JSONObject = (findOneBySpy.mock.calls[0]![0] as JSONObject)[
+        "query"
+      ] as JSONObject;
+
+      expect(query["sessionId"]).toBeUndefined();
+    });
+  });
+
+  describe("normalizeSecondsWatched", () => {
+    test("floors to the heartbeat bucket, clamps to the ceiling, and treats garbage as zero", () => {
+      expect(normalizeSecondsWatched(44)).toBe(30);
+      expect(normalizeSecondsWatched(SESSION_REPLAY_WATCH_BUCKET_SECONDS)).toBe(
+        SESSION_REPLAY_WATCH_BUCKET_SECONDS,
+      );
+      expect(normalizeSecondsWatched(14.9)).toBe(0);
+      expect(normalizeSecondsWatched(-5)).toBe(0);
+      expect(normalizeSecondsWatched(Number.NaN)).toBe(0);
+      expect(normalizeSecondsWatched(Number.POSITIVE_INFINITY)).toBe(0);
+      expect(normalizeSecondsWatched(10 ** 12)).toBe(
+        SESSION_REPLAY_MAX_SECONDS_WATCHED,
+      );
+    });
+  });
+
+  describe("recordSecondsWatched", () => {
+    const viewId: ObjectID = ObjectID.generate();
+
+    test("writes nothing for a figure that rounds to zero", async () => {
+      await RumSessionReplayViewService.recordSecondsWatched({
+        viewId: viewId,
+        projectId: projectId,
+        secondsWatched: 7,
+      });
+
+      expect(updateOneBySpy).not.toHaveBeenCalled();
+      expect(findOneBySpy).not.toHaveBeenCalled();
+    });
+
+    test("writes nothing when the caller's known figure already covers it", async () => {
+      await RumSessionReplayViewService.recordSecondsWatched({
+        viewId: viewId,
+        projectId: projectId,
+        secondsWatched: 44,
+        currentSecondsWatched: 30,
+      });
+
+      expect(updateOneBySpy).not.toHaveBeenCalled();
+    });
+
+    test("advances with a single guarded UPDATE scoped to the tenant", async () => {
+      await RumSessionReplayViewService.recordSecondsWatched({
+        viewId: viewId,
+        projectId: projectId,
+        secondsWatched: 44,
+        currentSecondsWatched: 15,
+      });
+
+      expect(findOneBySpy).not.toHaveBeenCalled();
+      expect(updateOneBySpy).toHaveBeenCalledTimes(1);
+
+      const args: JSONObject = updateOneBySpy.mock.calls[0]![0] as JSONObject;
+      const query: JSONObject = args["query"] as JSONObject;
+      const data: JSONObject = args["data"] as JSONObject;
+
+      expect(query["_id"]).toBe(viewId.toString());
+      expect((query["projectId"] as ObjectID).toString()).toBe(
+        projectId.toString(),
+      );
+      /*
+       * The monotonic guard is IN the predicate (a Raw "< :value OR IS
+       * NULL"), not a plain number - a plain number would be an equality
+       * match and the guard would be gone.
+       */
+      expect(query["secondsWatched"]).toBeDefined();
+      expect(typeof query["secondsWatched"]).not.toBe("number");
+      expect(data["secondsWatched"]).toBe(30);
+      expect((args["props"] as JSONObject)["isRoot"]).toBe(true);
+    });
+
+    test("still guards in the predicate when the caller holds no current figure", async () => {
+      await RumSessionReplayViewService.recordSecondsWatched({
+        viewId: viewId,
+        projectId: projectId,
+        secondsWatched: 90,
+      });
+
+      expect(updateOneBySpy).toHaveBeenCalledTimes(1);
+      const query: JSONObject = (
+        updateOneBySpy.mock.calls[0]![0] as JSONObject
+      )["query"] as JSONObject;
+      expect(query["secondsWatched"]).toBeDefined();
+    });
+  });
+
+  describe("getViewsForSession", () => {
+    test("is pinned to the application and clamps the page size", async () => {
+      const findBySpy: jest.SpyInstance = getJestSpyOn(
+        RumSessionReplayViewService,
+        "findBy",
+      ).mockResolvedValue([]);
+
+      await RumSessionReplayViewService.getViewsForSession({
+        projectId: projectId,
+        rumApplicationId: rumApplicationId,
+        sessionId: "s-1",
+        limit: 0,
+      });
+
+      const args: JSONObject = findBySpy.mock.calls[0]![0] as JSONObject;
+      const query: JSONObject = args["query"] as JSONObject;
+
+      expect((query["rumApplicationId"] as ObjectID).toString()).toBe(
+        rumApplicationId.toString(),
+      );
+      expect(query["sessionId"]).toBe("s-1");
+      expect(args["limit"]).toBe(1);
+      expect((args["props"] as JSONObject)["isRoot"]).toBe(true);
+    });
+  });
+});

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

@@ -1,11 +1,14 @@
 import TeamMember from "../../../Models/DatabaseModels/TeamMember";
 import User from "../../../Models/DatabaseModels/User";
 import Project from "../../../Models/DatabaseModels/Project";
+import Team from "../../../Models/DatabaseModels/Team";
 import DatabaseConfig from "../../../Server/DatabaseConfig";
 import MailService from "../../../Server/Services/MailService";
 import ProjectSCIMService from "../../../Server/Services/ProjectSCIMService";
 import ProjectService from "../../../Server/Services/ProjectService";
 import TeamMemberService from "../../../Server/Services/TeamMemberService";
+import TeamPermissionService from "../../../Server/Services/TeamPermissionService";
+import TeamService from "../../../Server/Services/TeamService";
 import UserNotificationRuleService from "../../../Server/Services/UserNotificationRuleService";
 import UserNotificationSettingService from "../../../Server/Services/UserNotificationSettingService";
 import UserService from "../../../Server/Services/UserService";
@@ -177,6 +180,12 @@ let addRuleSpy: jest.SpyInstance;
 let findUserByIdSpy: jest.SpyInstance;
 
 beforeEach(() => {
+  const team: Team = new Team(TEAM_ID);
+  jest.spyOn(TeamService, "findOneBy").mockResolvedValue(team);
+  jest
+    .spyOn(TeamPermissionService, "assertCanGrantTeamPermissions")
+    .mockResolvedValue(undefined);
+
   /*
    * The SCIM push-groups guard runs for every non-root create, so it has to
    * answer before anything else in onBeforeCreate is reachable.

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

@@ -1,6 +1,7 @@
 import EmailVerificationToken from "../../../Models/DatabaseModels/EmailVerificationToken";
 import Project from "../../../Models/DatabaseModels/Project";
 import TeamMember from "../../../Models/DatabaseModels/TeamMember";
+import Team from "../../../Models/DatabaseModels/Team";
 import User from "../../../Models/DatabaseModels/User";
 import DatabaseConfig from "../../../Server/DatabaseConfig";
 import EmailVerificationTokenService from "../../../Server/Services/EmailVerificationTokenService";
@@ -8,6 +9,8 @@ import MailService from "../../../Server/Services/MailService";
 import ProjectSCIMService from "../../../Server/Services/ProjectSCIMService";
 import ProjectService from "../../../Server/Services/ProjectService";
 import TeamMemberService from "../../../Server/Services/TeamMemberService";
+import TeamPermissionService from "../../../Server/Services/TeamPermissionService";
+import TeamService from "../../../Server/Services/TeamService";
 import UserNotificationRuleService from "../../../Server/Services/UserNotificationRuleService";
 import UserNotificationSettingService from "../../../Server/Services/UserNotificationSettingService";
 import UserService from "../../../Server/Services/UserService";
@@ -123,6 +126,12 @@ function persistedToken(): EmailVerificationToken {
 }
 
 beforeEach(() => {
+  const team: Team = new Team(TEAM_ID);
+  jest.spyOn(TeamService, "findOneBy").mockResolvedValue(team);
+  jest
+    .spyOn(TeamPermissionService, "assertCanGrantTeamPermissions")
+    .mockResolvedValue(undefined);
+
   jest
     .spyOn(ProjectSCIMService, "countBy")
     .mockResolvedValue(new PositiveNumber(0));