Add user merging tests

apps/rpc/src/modules/group/__test__/group-service.spec.ts

@@ -3,32 +3,34 @@ import type { Group } from "@dotkomonline/types"
 import { PrismaClient } from "@prisma/client"
 import type { ManagementClient } from "auth0"
 import { randomUUID } from "node:crypto"
-import { getFeideGroupsRepository } from "src/modules/feide/feide-groups-repository"
-import { getMembershipService } from "src/modules/user/membership-service"
-import { getUserRepository } from "src/modules/user/user-repository"
-import { getUserService } from "src/modules/user/user-service"
+import { getFeideGroupsRepository } from "../../feide/feide-groups-repository"
+import { getMembershipService } from "../../user/membership-service"
+import { getUserRepository } from "../../user/user-repository"
+import { getUserService } from "../../user/user-service"
 import { mockDeep } from "vitest-mock-extended"
 import { getGroupRepository } from "../group-repository"
 import { getGroupService } from "../group-service"
+import { describe, expect, it, vi } from "vitest"
 
 describe("GroupService", () => {
   const db = vi.mocked(PrismaClient.prototype)
   const auth0Client = mockDeep<ManagementClient>()
   const s3Client = mockDeep<S3Client>()
   const userRepository = getUserRepository()
   const feideGroupsRepository = getFeideGroupsRepository()
+  const groupRepository = getGroupRepository()
   const membershipService = getMembershipService()
 
   const userService = getUserService(
     userRepository,
     feideGroupsRepository,
+    groupRepository,
     auth0Client,
     membershipService,
     s3Client,
     "fake-aws-bucket"
   )
 
-  const groupRepository = getGroupRepository()
   const groupService = getGroupService(groupRepository, userService, s3Client, "fake-aws-bucket")
 
   it("creates a new group", async () => {

apps/rpc/src/modules/group/__test__/simplify-group-memberships.spec.ts

@@ -0,0 +1,156 @@
+import { randomUUID } from "node:crypto"
+import type { GroupMembership, GroupRole } from "@dotkomonline/types"
+import { describe, expect, it } from "vitest"
+import { simplifyGroupMemberships } from "../group-service"
+
+const roleA: GroupRole = { id: "role-a", name: "Role A", type: "COSMETIC", groupId: "group-1" }
+const roleB: GroupRole = { id: "role-b", name: "Role B", type: "COSMETIC", groupId: "group-1" }
+const roleC: GroupRole = { id: "role-c", name: "Role C", type: "COSMETIC", groupId: "group-1" }
+
+function makeMembership(overrides: Partial<GroupMembership> = {}): GroupMembership {
+  return {
+    id: randomUUID(),
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    groupId: "group-1",
+    userId: "user-1",
+    roles: [],
+    start: new Date("2024-01-01"),
+    end: new Date("2024-06-01"),
+    ...overrides,
+  }
+}
+
+describe("simplifyGroupMemberships", () => {
+  it("returns an empty array for no memberships", () => {
+    expect(simplifyGroupMemberships([])).toEqual([])
+  })
+
+  it("returns a single membership unchanged", () => {
+    const m = makeMembership({ roles: [roleA] })
+    const result = simplifyGroupMemberships([m])
+
+    expect(result).toHaveLength(1)
+    expect(result[0].start).toEqual(m.start)
+    expect(result[0].end).toEqual(m.end)
+    expect(result[0].roleIds).toEqual(new Set([roleA.id]))
+  })
+
+  it("merges adjacent memberships with identical roles into one", () => {
+    const m1 = makeMembership({ start: new Date("2024-01-01"), end: new Date("2024-03-01"), roles: [roleA] })
+    const m2 = makeMembership({ start: new Date("2024-03-01"), end: new Date("2024-06-01"), roles: [roleA] })
+
+    const result = simplifyGroupMemberships([m1, m2])
+
+    expect(result).toHaveLength(1)
+    expect(result[0].start).toEqual(new Date("2024-01-01"))
+    expect(result[0].end).toEqual(new Date("2024-06-01"))
+    expect(result[0].roleIds).toEqual(new Set([roleA.id]))
+  })
+
+  it("does not merge adjacent memberships with different roles", () => {
+    const m1 = makeMembership({ start: new Date("2024-01-01"), end: new Date("2024-03-01"), roles: [roleA] })
+    const m2 = makeMembership({ start: new Date("2024-03-01"), end: new Date("2024-06-01"), roles: [roleB] })
+
+    const result = simplifyGroupMemberships([m1, m2])
+
+    expect(result).toHaveLength(2)
+    expect(result[0].start).toEqual(new Date("2024-01-01"))
+    expect(result[0].end).toEqual(new Date("2024-03-01"))
+    expect(result[1].start).toEqual(new Date("2024-03-01"))
+    expect(result[1].end).toEqual(new Date("2024-06-01"))
+  })
+
+  it("splits overlapping memberships with different roles into segments", () => {
+    const mA = makeMembership({ start: new Date("2024-01-01"), end: new Date("2024-04-01"), roles: [roleA] })
+    const mB = makeMembership({ start: new Date("2024-02-01"), end: new Date("2024-06-01"), roles: [roleB] })
+
+    const result = simplifyGroupMemberships([mA, mB])
+
+    expect(result).toHaveLength(3)
+
+    expect(result[0].start).toEqual(new Date("2024-01-01"))
+    expect(result[0].end).toEqual(new Date("2024-02-01"))
+    expect(result[0].roleIds).toEqual(new Set([roleA.id]))
+
+    expect(result[1].start).toEqual(new Date("2024-02-01"))
+    expect(result[1].end).toEqual(new Date("2024-04-01"))
+    expect(result[1].roleIds).toEqual(new Set([roleA.id, roleB.id]))
+
+    expect(result[2].start).toEqual(new Date("2024-04-01"))
+    expect(result[2].end).toEqual(new Date("2024-06-01"))
+    expect(result[2].roleIds).toEqual(new Set([roleB.id]))
+  })
+
+  it("produces one segment for fully coincident memberships, combining roles", () => {
+    const mA = makeMembership({ start: new Date("2024-01-01"), end: new Date("2024-06-01"), roles: [roleA] })
+    const mB = makeMembership({ start: new Date("2024-01-01"), end: new Date("2024-06-01"), roles: [roleB] })
+
+    const result = simplifyGroupMemberships([mA, mB])
+
+    expect(result).toHaveLength(1)
+    expect(result[0].start).toEqual(new Date("2024-01-01"))
+    expect(result[0].end).toEqual(new Date("2024-06-01"))
+    expect(result[0].roleIds).toEqual(new Set([roleA.id, roleB.id]))
+  })
+
+  it("preserves end=null for an ongoing membership", () => {
+    const m = makeMembership({ start: new Date("2024-01-01"), end: null, roles: [roleA] })
+
+    const result = simplifyGroupMemberships([m])
+
+    expect(result).toHaveLength(1)
+    expect(result[0].end).toBeNull()
+  })
+
+  it("correctly segments an overlapping membership against an ongoing one", () => {
+    const mA = makeMembership({ start: new Date("2024-01-01"), end: new Date("2024-04-01"), roles: [roleA] })
+    const mB = makeMembership({ start: new Date("2024-02-01"), end: null, roles: [roleB] })
+
+    const result = simplifyGroupMemberships([mA, mB])
+
+    expect(result).toHaveLength(3)
+
+    expect(result[0].start).toEqual(new Date("2024-01-01"))
+    expect(result[0].end).toEqual(new Date("2024-02-01"))
+    expect(result[0].roleIds).toEqual(new Set([roleA.id]))
+
+    expect(result[1].start).toEqual(new Date("2024-02-01"))
+    expect(result[1].end).toEqual(new Date("2024-04-01"))
+    expect(result[1].roleIds).toEqual(new Set([roleA.id, roleB.id]))
+
+    expect(result[2].start).toEqual(new Date("2024-04-01"))
+    expect(result[2].end).toBeNull()
+    expect(result[2].roleIds).toEqual(new Set([roleB.id]))
+  })
+
+  it("handles the docstring example: A(0-2), B(1-4), C(3-5) → 5 segments", () => {
+    const mA = makeMembership({ start: new Date("2024-01-01"), end: new Date("2024-03-01"), roles: [roleA] })
+    const mB = makeMembership({ start: new Date("2024-02-01"), end: new Date("2024-05-01"), roles: [roleB] })
+    const mC = makeMembership({ start: new Date("2024-04-01"), end: new Date("2024-06-01"), roles: [roleC] })
+
+    const result = simplifyGroupMemberships([mA, mB, mC])
+
+    expect(result).toHaveLength(5)
+
+    expect(result[0].start).toEqual(new Date("2024-01-01"))
+    expect(result[0].end).toEqual(new Date("2024-02-01"))
+    expect(result[0].roleIds).toEqual(new Set([roleA.id]))
+
+    expect(result[1].start).toEqual(new Date("2024-02-01"))
+    expect(result[1].end).toEqual(new Date("2024-03-01"))
+    expect(result[1].roleIds).toEqual(new Set([roleA.id, roleB.id]))
+
+    expect(result[2].start).toEqual(new Date("2024-03-01"))
+    expect(result[2].end).toEqual(new Date("2024-04-01"))
+    expect(result[2].roleIds).toEqual(new Set([roleB.id]))
+
+    expect(result[3].start).toEqual(new Date("2024-04-01"))
+    expect(result[3].end).toEqual(new Date("2024-05-01"))
+    expect(result[3].roleIds).toEqual(new Set([roleB.id, roleC.id]))
+
+    expect(result[4].start).toEqual(new Date("2024-05-01"))
+    expect(result[4].end).toEqual(new Date("2024-06-01"))
+    expect(result[4].roleIds).toEqual(new Set([roleC.id]))
+  })
+})

apps/rpc/src/modules/user/membership.e2e-spec.ts → apps/rpc/src/modules/user/__test__/membership.spec.ts

@@ -1,4 +1,4 @@
-import { getMembershipService, MASTER_SEMESTER_OFFSET } from "./membership-service"
+import { getMembershipService, MASTER_SEMESTER_OFFSET } from "../membership-service"
 import { describe, expect, it, beforeEach, afterEach, vitest as vi } from "vitest"
 
 describe("Membership integration tests", () => {