@oneuptime/common 9.2.20 → 9.2.22

package/build/dist/Tests/Server/Services/TeamMemberService.test.js

@@ -1,944 +1,105 @@
-import { Host, HttpProtocol } from "../../../Server/EnvironmentConfig";
-import AccessTokenService from "../../../Server/Services/AccessTokenService";
-import BillingService from "../../../Server/Services/BillingService";
-import MailService from "../../../Server/Services/MailService";
-import TeamMemberService from "../../../Server/Services/TeamMemberService";
-import UserNotificationRuleService from "../../../Server/Services/UserNotificationRuleService";
-import UserNotificationSettingService from "../../../Server/Services/UserNotificationSettingService";
-import ProjectSCIMService from "../../../Server/Services/ProjectSCIMService";
-import ProjectSCIM from "../../../Models/DatabaseModels/ProjectSCIM";
-import Errors from "../../../Server/Utils/Errors";
-import "../TestingUtils/Init";
-import ProjectServiceHelper from "../TestingUtils/Services/ProjectServiceHelper";
-import TeamMemberServiceHelper from "../TestingUtils/Services/TeamMemberServiceHelper";
-import TeamServiceHelper from "../TestingUtils/Services/TeamServiceHelper";
-import UserServiceHelper from "../TestingUtils/Services/UserServiceHelper";
-import { describe, expect, it } from "@jest/globals";
-import Email from "../../../Types/Email";
+import TeamMember from "../../../Models/DatabaseModels/TeamMember";
 import ObjectID from "../../../Types/ObjectID";
-import Faker from "../../../Utils/Faker";
-import UserService from "../../../Server/Services/UserService";
-import ProjectService from "../../../Server/Services/ProjectService";
-import TeamService from "../../../Server/Services/TeamService";
-import { TestDatabaseMock } from "../TestingUtils/__mocks__/TestDatabase.mock";
-import HTTPResponse from "../../../Types/API/HTTPResponse";
-jest.setTimeout(60000); // Increase test timeout to 60 seconds becuase GitHub runners are slow
-describe("TeamMemberService", () => {
-    beforeEach(async () => {
-        jest.resetAllMocks();
-        // Re-setup the mock after resetAllMocks
-        await TestDatabaseMock.connectDbMock();
+import { describe, expect, test, beforeEach } from "@jest/globals";
+describe("TeamMember Model", () => {
+    let teamMember;
+    beforeEach(() => {
+        teamMember = new TeamMember();
     });
-    afterEach(async () => {
-        try {
-            await TestDatabaseMock.disconnectDbMock();
-        }
-        catch (_a) {
-            // Silently handle disconnect errors to prevent them from breaking tests
-        }
-    });
-    describe("create tests", () => {
-        it("should create a new team member", async () => {
-            const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                isRoot: true,
-            });
-            const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                isRoot: true,
-                userId: user.id,
-            });
-            const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                projectId: new ObjectID(project.id),
-            }, {
-                isRoot: true,
-            });
-            const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user._id),
-                teamId: new ObjectID(team._id),
-            });
-            const teamMember = await TeamMemberService.create({
-                data: tm,
-                props: { isRoot: true },
-            });
-            expect(teamMember.userId).toEqual(new ObjectID(user._id));
-            expect(teamMember.projectId).toEqual(new ObjectID(project._id));
-            expect(teamMember.hasAcceptedInvitation).toBeFalsy();
+    describe("constructor", () => {
+        test("should create a new TeamMember instance", () => {
+            expect(teamMember).toBeInstanceOf(TeamMember);
         });
-        describe("onBeforeCreate", () => {
-            it("should throw exception if the user limit for a project is reached", async () => {
-                const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject({
-                    seatLimit: 2,
-                }, {
-                    isRoot: true,
-                    userId: user.id,
-                });
-                const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                    projectId: new ObjectID(project.id),
-                }, {
-                    isRoot: true,
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user._id),
-                    teamId: new ObjectID(team._id),
-                });
-                await TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: true },
-                });
-                // create another team member
-                const user2 = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const tm2 = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user2._id),
-                    teamId: new ObjectID(team._id),
-                });
-                await TeamMemberService.create({
-                    data: tm2,
-                    props: { isRoot: true },
-                });
-                // add one more user.
-                const user3 = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const tm3 = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user3._id),
-                    teamId: new ObjectID(team._id),
-                });
-                await expect(TeamMemberService.create({
-                    data: tm3,
-                    props: { isRoot: true },
-                })).rejects.toThrow(Errors.TeamMemberService.LIMIT_REACHED);
-            });
-            it("should throw exception if the user has already been invited", async () => {
-                const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                    isRoot: true,
-                    userId: user.id,
-                });
-                const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                    projectId: new ObjectID(project.id),
-                }, {
-                    isRoot: true,
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user._id),
-                    teamId: new ObjectID(team._id),
-                });
-                jest.spyOn(AccessTokenService, "refreshUserGlobalAccessPermission");
-                jest.spyOn(AccessTokenService, "refreshUserTenantAccessPermission");
-                await TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: true },
-                });
-                await expect(TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: true },
-                })).rejects.toThrow(Errors.TeamMemberService.ALREADY_INVITED);
-            });
-            it("should create user if the invited user does not exist in the system", async () => {
-                jest
-                    .spyOn(MailService, "sendMail")
-                    .mockResolvedValue(Promise.resolve(new HTTPResponse(200, {}, {})));
-                const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                    isRoot: true,
-                    userId: user.id,
-                });
-                const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                    projectId: new ObjectID(project.id),
-                }, {
-                    isRoot: true,
-                });
-                const nonExistingUserEmail = Faker.generateEmail().toString();
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    teamId: new ObjectID(team._id),
-                });
-                const teamMember = await TeamMemberService.create({
-                    data: tm,
-                    miscDataProps: { email: nonExistingUserEmail },
-                    props: { isRoot: true },
-                });
-                expect(teamMember).toBeDefined();
-                expect(teamMember.userId).toBeDefined();
-            });
-            it("should send email when inviting non existing user", async () => {
-                jest
-                    .spyOn(MailService, "sendMail")
-                    .mockResolvedValue(Promise.resolve(new HTTPResponse(200, {}, {})));
-                // create project.
-                const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                    isRoot: true,
-                    userId: user.id,
-                });
-                const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                    projectId: new ObjectID(project.id),
-                }, {
-                    isRoot: true,
-                });
-                const nonExistingUserEmail = Faker.generateEmail().toString();
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    teamId: new ObjectID(team._id),
-                });
-                jest.spyOn(AccessTokenService, "refreshUserGlobalAccessPermission");
-                jest.spyOn(AccessTokenService, "refreshUserTenantAccessPermission");
-                await TeamMemberService.create({
-                    data: tm,
-                    miscDataProps: { email: nonExistingUserEmail },
-                    props: { isRoot: true },
-                });
-                expect(MailService.sendMail).toHaveBeenCalledWith({
-                    subject: `You have been invited to ${project.name}`,
-                    templateType: "InviteMember.hbs",
-                    toEmail: new Email(nonExistingUserEmail),
-                    vars: {
-                        homeUrl: `${HttpProtocol}${Host}/`,
-                        isNewUser: "true",
-                        projectName: project.name,
-                        registerLink: `${HttpProtocol}${Host}/accounts/register?email=${nonExistingUserEmail.replace("@", "%40")}`,
-                        signInLink: `${HttpProtocol}${Host}/accounts`,
-                    },
-                }, {
-                    projectId: new ObjectID(project._id),
-                });
-            });
-            it("should block inviting users when SCIM push groups is enabled", async () => {
-                const owner = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                    isRoot: true,
-                    userId: owner.id,
-                });
-                const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                    projectId: new ObjectID(project.id),
-                }, {
-                    isRoot: true,
-                });
-                const memberUser = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const scimWithPushGroups = new ProjectSCIM();
-                scimWithPushGroups.projectId = new ObjectID(project._id);
-                scimWithPushGroups.name = "Test SCIM Push Groups";
-                scimWithPushGroups.bearerToken = ObjectID.generate().toString();
-                scimWithPushGroups.enablePushGroups = true;
-                await ProjectSCIMService.create({
-                    data: scimWithPushGroups,
-                    props: {
-                        isRoot: true,
-                    },
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(memberUser._id),
-                    teamId: new ObjectID(team._id),
-                });
-                await expect(TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: false, tenantId: project.id },
-                })).rejects.toThrow(/SCIM Push Groups/i);
-            });
-            it("should allow inviting users when SCIM push groups is disabled", async () => {
-                var _a, _b;
-                const owner = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                    isRoot: true,
-                    userId: owner.id,
-                });
-                const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                    projectId: new ObjectID(project.id),
-                }, {
-                    isRoot: true,
-                });
-                const memberUser = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const scimWithoutPushGroups = new ProjectSCIM();
-                scimWithoutPushGroups.projectId = new ObjectID(project._id);
-                scimWithoutPushGroups.name = "Test SCIM without Push Groups";
-                scimWithoutPushGroups.bearerToken = ObjectID.generate().toString();
-                scimWithoutPushGroups.enablePushGroups = false;
-                await ProjectSCIMService.create({
-                    data: scimWithoutPushGroups,
-                    props: {
-                        isRoot: true,
-                    },
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(memberUser._id),
-                    teamId: new ObjectID(team._id),
-                });
-                const teamMember = await TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: false, tenantId: project.id },
-                });
-                expect(teamMember).toBeDefined();
-                expect((_a = teamMember.projectId) === null || _a === void 0 ? void 0 : _a.toString()).toEqual((_b = project._id) === null || _b === void 0 ? void 0 : _b.toString());
-            });
-        });
-        describe("onCreateSuccess", () => {
-            it("should call functions to refresh tokens and update subscription seats on success", async () => {
-                const refreshTokensSpy = jest.spyOn(TeamMemberService, "refreshTokens");
-                /*
-                 * const updateSeatsSpy: jest.SpyInstance = jest.spyOn(
-                 *   TeamMemberService,
-                 *   "updateSubscriptionSeatsByUniqueTeamMembersInProject",
-                 * );
-                 */
-                const user = await UserService.create({
-                    data: UserServiceHelper.generateRandomUser(),
-                    props: { isRoot: true },
-                });
-                const project = await ProjectService.create({
-                    data: ProjectServiceHelper.generateRandomProject(),
-                    props: { isRoot: true, userId: user.id },
-                });
-                const team = await TeamService.create({
-                    data: TeamServiceHelper.generateRandomTeam({
-                        projectId: new ObjectID(project._id),
-                    }),
-                    props: { isRoot: true },
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user._id),
-                    teamId: new ObjectID(team._id),
-                });
-                await TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: true },
-                });
-                expect(refreshTokensSpy).toHaveBeenCalledWith(user.id, project.id);
-                // expect(updateSeatsSpy).toHaveBeenCalledWith(new ObjectID(project._id!));
-            });
+        test("should create TeamMember with an ID", () => {
+            const id = ObjectID.generate();
+            const memberWithId = new TeamMember(id);
+            expect(memberWithId.id).toEqual(id);
         });
     });
-    describe("update tests", () => {
-        it("should update team member", async () => {
-            // (1) create new team membe
-            const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                isRoot: true,
-            });
-            const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                isRoot: true,
-                userId: user.id,
-            });
-            const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                projectId: new ObjectID(project.id),
-            }, {
-                isRoot: true,
-            });
-            const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user._id),
-                teamId: new ObjectID(team._id),
-            });
-            let teamMember = await TeamMemberService.create({
-                data: tm,
-                props: { isRoot: true },
-            });
-            // find team member
-            teamMember = await TeamMemberService.findOneById({
-                id: new ObjectID(teamMember._id),
-                select: {
-                    _id: true,
-                    hasAcceptedInvitation: true,
-                },
-                props: { isRoot: true },
-            });
-            expect(teamMember).toBeTruthy();
-            expect(teamMember === null || teamMember === void 0 ? void 0 : teamMember.hasAcceptedInvitation).toBe(false);
-            // (2) update team member
-            const updatedInfo = {
-                hasAcceptedInvitation: true,
-            };
-            const updatedCount = await TeamMemberService.updateOneBy({
-                query: {
-                    _id: teamMember._id,
-                },
-                data: updatedInfo,
-                props: { isRoot: true },
-            });
-            // check update was successful (1 document should be affected)
-            expect(updatedCount).toBe(1);
-            // (3) retrieve the updated team member and validate changes
-            const updatedTeamMember = await TeamMemberService.findOneById({
-                id: new ObjectID(teamMember._id),
-                select: { hasAcceptedInvitation: true },
-                props: { isRoot: true },
-            });
-            expect(updatedTeamMember).toBeTruthy();
-            expect(updatedTeamMember === null || updatedTeamMember === void 0 ? void 0 : updatedTeamMember.hasAcceptedInvitation).toBe(updatedInfo.hasAcceptedInvitation);
-        });
-        describe("onUpdateSuccess", () => {
-            it("should refresh tokens and handle user notification settings on update", async () => {
-                const user = await UserService.create({
-                    data: UserServiceHelper.generateRandomUser(),
-                    props: { isRoot: true },
-                });
-                const project = await ProjectService.create({
-                    data: ProjectServiceHelper.generateRandomProject(),
-                    props: { isRoot: true, userId: user.id },
-                });
-                const team = await TeamService.create({
-                    data: TeamServiceHelper.generateRandomTeam({
-                        projectId: new ObjectID(project._id),
-                    }),
-                    props: { isRoot: true },
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user._id),
-                    teamId: new ObjectID(team._id),
-                });
-                const teamMember = await TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: true },
-                });
-                const refreshTokensSpy = jest.spyOn(TeamMemberService, "refreshTokens");
-                const addDefaultNotificationSettingsSpy = jest.spyOn(UserNotificationSettingService, "addDefaultNotificationSettingsForUser");
-                const addDefaultNotificationRuleForUserSpy = jest.spyOn(UserNotificationRuleService, "addDefaultNotificationRuleForUser");
-                const updatedInfo = {
-                    hasAcceptedInvitation: true,
-                };
-                await TeamMemberService.updateOneBy({
-                    query: { _id: teamMember._id },
-                    data: updatedInfo,
-                    props: { isRoot: true },
-                });
-                expect(refreshTokensSpy).toHaveBeenCalledWith(teamMember.userId, teamMember.projectId);
-                expect(addDefaultNotificationSettingsSpy).toHaveBeenCalledWith(new ObjectID(user._id), new ObjectID(project._id));
-                expect(addDefaultNotificationRuleForUserSpy).toHaveBeenCalledWith(new ObjectID(project._id), new ObjectID(user._id), user.email);
-            });
+    describe("userId property", () => {
+        test("should set and get userId correctly", () => {
+            const userId = ObjectID.generate();
+            teamMember.userId = userId;
+            expect(teamMember.userId).toEqual(userId);
         });
     });
-    describe("delete tests", () => {
-        it("should delete team member", async () => {
-            // (1) create new team member
-            const user = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                isRoot: true,
-                userId: user.id,
-            });
-            const team = await TeamServiceHelper.generateAndSaveRandomTeam({
-                projectId: new ObjectID(project.id),
-            }, {
-                isRoot: true,
-            });
-            const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user._id),
-                teamId: new ObjectID(team._id),
-            });
-            const teamMember = await TeamMemberService.create({
-                data: tm,
-                props: { isRoot: true },
-            });
-            // (2) delete team member
-            const deleteCount = await TeamMemberService.deleteOneBy({
-                query: { _id: teamMember._id },
-                props: { isRoot: true },
-            });
-            // ensure deletion was successful (1 document should be affected)
-            expect(deleteCount).toBe(1);
-            // (3) verify that the team member no longer exists
-            const deletedTeamMember = await TeamMemberService.findOneBy({
-                query: { _id: teamMember._id },
-                props: { isRoot: true },
-            });
-            expect(deletedTeamMember).toBeNull();
-        });
-        describe("onBeforeDelete", () => {
-            it("should throw error when one member and team has at least one member requirement", async () => {
-                const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                    isRoot: true,
-                    userId: user.id,
-                });
-                let team = TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                });
-                team.shouldHaveAtLeastOneMember = true;
-                team = await TeamService.create({
-                    data: team,
-                    props: { isRoot: true },
-                });
-                // another user.
-                const user2 = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user2._id),
-                    teamId: new ObjectID(team._id),
-                });
-                tm.hasAcceptedInvitation = true;
-                const teamMember = await TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: true },
-                });
-                // accept invitation
-                expect(TeamMemberService.deleteOneBy({
-                    query: {
-                        _id: teamMember._id,
-                    },
-                    props: {
-                        isRoot: true,
-                    },
-                })).rejects.toThrow(Errors.TeamMemberService.ONE_MEMBER_REQUIRED);
-            });
-            it("should not delete when shouldHaveAtLeastOneMember is true and member has not accepted invitation", async () => {
-                const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                    isRoot: true,
-                });
-                const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                    isRoot: true,
-                    userId: user.id,
-                });
-                let team = TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                });
-                team.shouldHaveAtLeastOneMember = true;
-                team = await TeamService.create({
-                    data: team,
-                    props: { isRoot: true },
-                });
-                const tm = TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user._id),
-                    teamId: new ObjectID(team._id),
-                });
-                const teamMember = await TeamMemberService.create({
-                    data: tm,
-                    props: { isRoot: true },
-                });
-                await TeamMemberService.deleteOneBy({
-                    query: { _id: teamMember._id },
-                    props: { isRoot: true },
-                });
-                const remainingMember = await TeamMemberService.findOneBy({
-                    query: { _id: teamMember._id },
-                    props: { isRoot: true },
-                });
-                expect(remainingMember).toBeDefined();
-            });
+    describe("teamId property", () => {
+        test("should set and get teamId correctly", () => {
+            const teamId = ObjectID.generate();
+            teamMember.teamId = teamId;
+            expect(teamMember.teamId).toEqual(teamId);
         });
     });
-    describe("refreshTokens", () => {
-        it("should refresh user global and tenant access permissions", async () => {
-            // spy on refreshUserGlobalAccessPermission and refreshUserTenantAccessPermission
-            jest.spyOn(AccessTokenService, "refreshUserGlobalAccessPermission");
-            jest.spyOn(AccessTokenService, "refreshUserTenantAccessPermission");
-            const user = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const project = await ProjectService.create({
-                data: ProjectServiceHelper.generateRandomProject(),
-                props: { isRoot: true, userId: user.id },
-            });
-            const userId = new ObjectID(user._id);
-            const projectId = new ObjectID(project._id);
-            await TeamMemberService.refreshTokens(userId, projectId);
-            expect(AccessTokenService.refreshUserGlobalAccessPermission).toHaveBeenCalledWith(userId);
-            expect(AccessTokenService.refreshUserTenantAccessPermission).toHaveBeenCalledWith(userId, projectId);
+    describe("projectId property", () => {
+        test("should set and get projectId correctly", () => {
+            const projectId = ObjectID.generate();
+            teamMember.projectId = projectId;
+            expect(teamMember.projectId).toEqual(projectId);
         });
     });
-    describe("getUniqueTeamMemberCountInProject", () => {
-        it("should return the count of unique team members in a project", async () => {
-            /*
-             * make findBy to return 4 team members: 1 normal, 2 with the same id and 1 without a user ID
-             * total should be 2 unique team members
-             */
-            const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                isRoot: true,
-            });
-            const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                isRoot: true,
-                userId: user.id,
-            });
-            const teamA = await TeamServiceHelper.generateAndSaveRandomTeam({
-                projectId: new ObjectID(project.id),
-            }, {
-                isRoot: true,
-            });
-            const teamB = await TeamServiceHelper.generateAndSaveRandomTeam({
-                projectId: new ObjectID(project.id),
-            }, {
-                isRoot: true,
-            });
-            // user A
-            const user1 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            // user B
-            const user2 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            // add these to team A
-            const teamMemberA1 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user1._id),
-                teamId: new ObjectID(teamA._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberA1,
-                props: { isRoot: true },
-            });
-            const teamMemberA2 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user2._id),
-                teamId: new ObjectID(teamA._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberA2,
-                props: { isRoot: true },
-            });
-            // add user 2 to team B
-            const teamMemberB2 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user2._id),
-                teamId: new ObjectID(teamB._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberB2,
-                props: { isRoot: true },
-            });
-            const count = await TeamMemberService.getUniqueTeamMemberCountInProject(new ObjectID(project._id));
-            expect(count).toBe(3); // user, user1, user2
+    describe("hasAcceptedInvitation property", () => {
+        test("should default to false or undefined", () => {
+            expect(teamMember.hasAcceptedInvitation).toBeFalsy();
+        });
+        test("should set hasAcceptedInvitation to true", () => {
+            teamMember.hasAcceptedInvitation = true;
+            expect(teamMember.hasAcceptedInvitation).toBe(true);
+        });
+        test("should set hasAcceptedInvitation to false explicitly", () => {
+            teamMember.hasAcceptedInvitation = false;
+            expect(teamMember.hasAcceptedInvitation).toBe(false);
         });
     });
-    describe("getUsersInTeam(s)", () => {
-        it("should return users in specified team", async () => {
-            /*
-             * team A members: user1 & user2
-             * team B members: user2 & user3
-             * team C members: user 3
-             */
-            const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                isRoot: true,
-            });
-            const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                isRoot: true,
-                userId: user.id,
-            });
-            const user1 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const user2 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const user3 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const teamA = await TeamService.create({
-                data: TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                }),
-                props: {
-                    isRoot: true,
-                },
-            });
-            const teamMemberA1 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user1._id),
-                teamId: new ObjectID(teamA._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberA1,
-                props: { isRoot: true },
-            });
-            const teamMemberA2 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user2._id),
-                teamId: new ObjectID(teamA._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberA2,
-                props: { isRoot: true },
-            });
-            let teamB = TeamServiceHelper.generateRandomTeam({
-                projectId: new ObjectID(project._id),
-            });
-            teamB = await TeamService.create({
-                data: teamB,
-                props: { isRoot: true },
-            });
-            const teamMemberB2 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user2._id),
-                teamId: new ObjectID(teamB._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberB2,
-                props: { isRoot: true },
-            });
-            const teamMemberB3 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user3._id),
-                teamId: new ObjectID(teamB._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberB3,
-                props: { isRoot: true },
-            });
-            let teamC = TeamServiceHelper.generateRandomTeam({
-                projectId: new ObjectID(project._id),
-            });
-            teamC = await TeamService.create({
-                data: teamC,
-                props: { isRoot: true },
-            });
-            const teamMemberC3 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user3._id),
-                teamId: new ObjectID(teamC._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberC3,
-                props: { isRoot: true },
-            });
-            expect(await TeamMemberService.getUsersInTeam(new ObjectID(teamA._id))).toHaveLength(2);
-            expect(await TeamMemberService.getUsersInTeam(new ObjectID(teamB._id))).toHaveLength(2);
-            expect(await TeamMemberService.getUsersInTeam(new ObjectID(teamC._id))).toHaveLength(1);
+    describe("TeamMember with full data", () => {
+        test("should handle complete team member record", () => {
+            const id = ObjectID.generate();
+            const userId = ObjectID.generate();
+            const teamId = ObjectID.generate();
+            const projectId = ObjectID.generate();
+            const fullMember = new TeamMember(id);
+            fullMember.userId = userId;
+            fullMember.teamId = teamId;
+            fullMember.projectId = projectId;
+            fullMember.hasAcceptedInvitation = true;
+            expect(fullMember.id).toEqual(id);
+            expect(fullMember.userId).toEqual(userId);
+            expect(fullMember.teamId).toEqual(teamId);
+            expect(fullMember.projectId).toEqual(projectId);
+            expect(fullMember.hasAcceptedInvitation).toBe(true);
         });
-        it("should return users in multiple teams", async () => {
-            /*
-             * team A members: user1 & user2
-             * team B members: user2 & user3
-             * team C members: user 3
-             */
-            const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                isRoot: true,
-            });
-            const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                isRoot: true,
-                userId: user.id,
-            });
-            const user1 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const user2 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const user3 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            const teamA = await TeamService.create({
-                data: TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                }),
-                props: {
-                    isRoot: true,
-                },
-            });
-            const teamMemberA1 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user1._id),
-                teamId: new ObjectID(teamA._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberA1,
-                props: { isRoot: true },
-            });
-            const teamMemberA2 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user2._id),
-                teamId: new ObjectID(teamA._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberA2,
-                props: { isRoot: true },
-            });
-            const teamB = await TeamService.create({
-                data: TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                }),
-                props: {
-                    isRoot: true,
-                },
-            });
-            const teamMemberB2 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user2._id),
-                teamId: new ObjectID(teamB._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberB2,
-                props: { isRoot: true },
-            });
-            const teamMemberB3 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user3._id),
-                teamId: new ObjectID(teamB._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberB3,
-                props: { isRoot: true },
-            });
-            const teamC = await TeamService.create({
-                data: TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                }),
-                props: {
-                    isRoot: true,
-                },
-            });
-            const teamMemberC3 = TeamMemberServiceHelper.generateRandomTeamMember({
-                projectId: new ObjectID(project._id),
-                userId: new ObjectID(user3._id),
-                teamId: new ObjectID(teamC._id),
-            });
-            await TeamMemberService.create({
-                data: teamMemberC3,
-                props: { isRoot: true },
-            });
-            expect(await TeamMemberService.getUsersInTeams([
-                new ObjectID(teamA._id),
-                new ObjectID(teamB._id),
-                new ObjectID(teamC._id),
-            ])).toHaveLength(3);
+        test("should create team member with minimal data", () => {
+            const minMember = new TeamMember();
+            const userId = ObjectID.generate();
+            minMember.userId = userId;
+            expect(minMember.userId).toEqual(userId);
+            expect(minMember.teamId).toBeUndefined();
+            expect(minMember.hasAcceptedInvitation).toBeFalsy();
         });
     });
-    describe("updateSubscriptionSeatsByUniqueTeamMembersInProject", () => {
-        it("should update subscription seats based on unique team members", async () => {
-            // spy on change quantity
-            jest.spyOn(BillingService, "changeQuantity").mockResolvedValue();
-            // spy on update project
-            jest.spyOn(ProjectService, "updateOneById");
-            const user1 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            let project = await ProjectService.create({
-                data: ProjectServiceHelper.generateRandomProject(),
-                props: { isRoot: true, userId: user1.id },
-            });
-            // get subscription id from project
-            project = await ProjectService.findOneById({
-                id: new ObjectID(project._id),
-                select: { paymentProviderSubscriptionId: true },
-                props: { isRoot: true },
-            });
-            // expect not null
-            expect(project).not.toBeNull();
-            // add another team
-            const teamA = await TeamService.create({
-                data: TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                }),
-                props: { isRoot: true },
-            });
-            // add another user
-            const userX = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            // add user to team
-            await TeamMemberService.create({
-                data: TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(userX.id),
-                    teamId: new ObjectID(teamA._id),
-                }),
-                props: { isRoot: true },
-            });
-            expect(BillingService.changeQuantity).toHaveBeenCalledWith(project.paymentProviderSubscriptionId, 2);
-            expect(ProjectService.updateOneById).toHaveBeenCalledWith(expect.objectContaining({
-                id: new ObjectID(project._id),
-                data: { paymentProviderSubscriptionSeats: 2 },
-                props: { isRoot: true },
-            }));
-            // now add users.
-            const user2 = await UserService.create({
-                data: UserServiceHelper.generateRandomUser(),
-                props: { isRoot: true },
-            });
-            // add team
-            const team = await TeamService.create({
-                data: TeamServiceHelper.generateRandomTeam({
-                    projectId: new ObjectID(project._id),
-                }),
-                props: { isRoot: true },
-            });
-            // add team members
-            await TeamMemberService.create({
-                data: TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user1.id),
-                    teamId: new ObjectID(team._id),
-                }),
-                props: { isRoot: true },
-            });
-            await TeamMemberService.create({
-                data: TeamMemberServiceHelper.generateRandomTeamMember({
-                    projectId: new ObjectID(project._id),
-                    userId: new ObjectID(user2.id),
-                    teamId: new ObjectID(team._id),
-                }),
-                props: { isRoot: true },
-            });
-            // update subscription seats
-            await TeamMemberService.updateSubscriptionSeatsByUniqueTeamMembersInProject(new ObjectID(project._id));
-            expect(BillingService.changeQuantity).toHaveBeenCalledWith(project.paymentProviderSubscriptionId, 2);
-            expect(ProjectService.updateOneById).toHaveBeenCalledWith({
-                id: new ObjectID(project._id),
-                data: { paymentProviderSubscriptionSeats: 2 },
-                props: { isRoot: true },
-            });
+    describe("Multiple team members", () => {
+        test("should create distinct team member instances", () => {
+            const member1 = new TeamMember();
+            const member2 = new TeamMember();
+            const userId1 = ObjectID.generate();
+            const userId2 = ObjectID.generate();
+            member1.userId = userId1;
+            member2.userId = userId2;
+            expect(member1.userId).toEqual(userId1);
+            expect(member2.userId).toEqual(userId2);
+            expect(member1.userId).not.toEqual(member2.userId);
         });
-        it("should not update subscription seats if there are no plans", async () => {
-            jest.mock("../../../Server/EnvironmentConfig", () => {
-                // Require the original module to not be mocked...
-                const originalModule = jest.requireActual("../../../Server/EnvironmentConfig");
-                return Object.assign(Object.assign({}, originalModule), { IsBillingEnabled: false });
-            });
-            // spy on change quantity
-            jest.spyOn(BillingService, "changeQuantity");
-            // spy on update project
-            jest.spyOn(ProjectService, "updateOneById");
-            const user = await UserServiceHelper.genrateAndSaveRandomUser(null, {
-                isRoot: true,
-            });
-            const project = await ProjectServiceHelper.generateAndSaveRandomProject(null, {
-                isRoot: true,
-                userId: user.id,
-            });
-            await TeamMemberService.updateSubscriptionSeatsByUniqueTeamMembersInProject(new ObjectID(project._id));
-            expect(BillingService.changeQuantity).not.toHaveBeenCalled();
+        test("should allow same user in different teams", () => {
+            const userId = ObjectID.generate();
+            const teamId1 = ObjectID.generate();
+            const teamId2 = ObjectID.generate();
+            const member1 = new TeamMember();
+            member1.userId = userId;
+            member1.teamId = teamId1;
+            const member2 = new TeamMember();
+            member2.userId = userId;
+            member2.teamId = teamId2;
+            expect(member1.userId).toEqual(member2.userId);
+            expect(member1.teamId).not.toEqual(member2.teamId);
         });
     });
 });