// @vitest-environment node import { beforeEach, describe, expect, it, vi } from "vitest"; import { TenantUserType } from "~/application/enums/tenants/TenantUserType"; const permissionCacheMock = vi.hoisted(() => ({ get: vi.fn(), set: vi.fn(), invalidate: vi.fn(), invalidateScopes: vi.fn(), })); vi.mock("../../db.server", () => ({ db: { permission: { count: vi.fn(), }, role: { findFirst: vi.fn(), findMany: vi.fn(), }, userRole: { count: vi.fn(), create: vi.fn(), createMany: vi.fn(), deleteMany: vi.fn(), findFirst: vi.fn(), findMany: vi.fn(), }, }, })); vi.mock("~/utils/cache.server", () => ({ clearCacheKey: vi.fn(), })); vi.mock("./permission-cache.server", async () => { const { clearCacheKey } = await import("~/utils/cache.server"); permissionCacheMock.invalidate.mockImplementation(async (userId: string, tenantId: string | null) => { clearCacheKey(`userRoles:${userId}:${tenantId}`); }); permissionCacheMock.invalidateScopes.mockImplementation(async (scopes: Array<{ userId: string; tenantId: string | null }>) => { for (const scope of scopes) await permissionCacheMock.invalidate(scope.userId, scope.tenantId); }); return { getCachedPermissionNames: permissionCacheMock.get, cachePermissionNames: permissionCacheMock.set, invalidateUserPermissionCache: permissionCacheMock.invalidate, invalidateUserPermissionCacheScopes: permissionCacheMock.invalidateScopes, }; }); import { clearCacheKey } from "~/utils/cache.server"; import { db } from "../../db.server"; import { countUserPermission, createUserRole, createUserRoles, deleteAllUserRoles, deleteUserRole, ensureAdminUserRoleByName, ensureTenantUserAppRoles, findPermissionByUser, findUserRolesByIds, getPermissionsByUser, getUserRole, getUserRoleInAdmin, getUserRoleInTenant, getUserRoles, getUsersRolesInTenant, reconcileAdminUserRoleByName, userHasPermission, } from "./userRoles.db.server"; const dbMock = vi.mocked(db); describe("user role persistence", () => { beforeEach(() => { vi.clearAllMocks(); permissionCacheMock.get.mockResolvedValue(null); permissionCacheMock.set.mockResolvedValue(false); }); it("queries user-role relationships with tenant and admin scope", async () => { vi.mocked(dbMock.userRole.findFirst).mockResolvedValue({ id: "ur_1" } as never); vi.mocked(dbMock.userRole.findMany).mockResolvedValue([] as never); await getUserRole("user_1", "role_1", "tenant_1"); await getUserRoleInTenant("user_1", "tenant_1", "Admin"); await getUserRoleInAdmin("user_1", "SuperAdmin"); await getUserRoles("user_1", "tenant_1"); expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(1, { where: { userId: "user_1", roleId: "role_1", tenantId: "tenant_1" }, }); expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(2, { where: { userId: "user_1", role: { name: "Admin" }, tenantId: "tenant_1" }, }); expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(3, { where: { userId: "user_1", role: { name: "SuperAdmin", type: "admin" }, tenantId: null }, }); expect(dbMock.userRole.findMany).toHaveBeenCalledWith( expect.objectContaining({ where: { userId: "user_1", tenantId: "tenant_1" }, orderBy: { role: { order: "asc" } }, }) ); }); it("deduplicates permissions returned from cached user-role expansion", async () => { vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([ { role: { name: "Admin", permissions: [{ permission: { name: "members.read" } }, { permission: { name: "members.read" } }], }, }, { role: { name: "Member", permissions: [{ permission: { name: "settings.update" } }], }, }, ] as never); await expect(getPermissionsByUser("user_1", "tenant_1")).resolves.toEqual(["members.read", "settings.update"]); expect(permissionCacheMock.get).toHaveBeenCalledWith("user_1", "tenant_1"); expect(permissionCacheMock.set).toHaveBeenCalledWith("user_1", "tenant_1", ["members.read", "settings.update"]); }); it("checks permission membership through the cached user-role expansion", async () => { vi.mocked(dbMock.userRole.findMany) .mockResolvedValueOnce([ { role: { name: "Admin", permissions: [{ permission: { name: "members.read" } }], }, }, ] as never) .mockResolvedValueOnce([ { role: { name: "Admin", permissions: [{ permission: { name: "members.read" } }], }, }, ] as never); await expect(userHasPermission("user_1", "tenant_1", "members.read")).resolves.toBe(true); await expect(userHasPermission("user_1", "tenant_1", "settings.update")).resolves.toBe(false); expect(permissionCacheMock.get).toHaveBeenCalledWith("user_1", "tenant_1"); expect(dbMock.permission.count).not.toHaveBeenCalled(); }); it("does not repopulate a stale grant when revocation races a cache miss", async () => { permissionCacheMock.set.mockResolvedValue(true); vi.mocked(dbMock.userRole.findMany) .mockResolvedValueOnce([ { role: { name: "Admin", permissions: [{ permission: { name: "members.delete" } }], }, }, ] as never) .mockResolvedValueOnce([] as never); await expect(getPermissionsByUser("user_1", "tenant_1")).resolves.toEqual([]); expect(permissionCacheMock.invalidate).toHaveBeenCalledWith("user_1", "tenant_1"); expect(permissionCacheMock.set).toHaveBeenLastCalledWith("user_1", "tenant_1", []); }); it("returns the first matching permission name or null", async () => { vi.mocked(dbMock.userRole.findMany) .mockResolvedValueOnce([ { role: { name: "Admin", permissions: [{ permission: { name: "members.read" } }], }, }, ] as never) .mockResolvedValueOnce([] as never); await expect(findPermissionByUser("members.read", "user_1", "tenant_1")).resolves.toBe("members.read"); await expect(findPermissionByUser("members.read", "user_1", "tenant_1")).resolves.toBeNull(); expect(dbMock.userRole.findMany).toHaveBeenNthCalledWith( 1, expect.objectContaining({ where: { userId: "user_1", tenantId: "tenant_1", role: { permissions: { some: { permission: { name: "members.read" } } } }, }, }) ); }); it("counts direct role permission matches and returns zero when none exist", async () => { vi.mocked(dbMock.permission.count).mockResolvedValueOnce(2).mockResolvedValueOnce(0); await expect(countUserPermission("user_1", "tenant_1", "members.read")).resolves.toBe(2); await expect(countUserPermission("user_1", "tenant_1", "members.read")).resolves.toBe(0); expect(dbMock.permission.count).toHaveBeenCalledWith({ where: { name: "members.read", inRoles: { some: { role: { users: { some: { userId: "user_1", tenantId: "tenant_1" } } } } }, }, }); }); it("queries bulk role helpers by ids, tenant, and type", async () => { vi.mocked(dbMock.userRole.findMany).mockResolvedValue([] as never); vi.mocked(dbMock.userRole.deleteMany).mockResolvedValue({ count: 2 } as never); await findUserRolesByIds("user_1", "tenant_1", ["role_1", "role_2"]); await getUsersRolesInTenant("tenant_1"); await deleteAllUserRoles("user_1", "app"); expect(dbMock.userRole.findMany).toHaveBeenNthCalledWith(1, { where: { userId: "user_1", tenantId: "tenant_1", roleId: { in: ["role_1", "role_2"] } }, }); expect(dbMock.userRole.findMany).toHaveBeenNthCalledWith(2, { where: { tenantId: "tenant_1" }, include: { role: true, user: true }, }); expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({ where: { userId: "user_1", role: { type: "app" } }, }); }); it("returns early from app-role repair when the user already has tenant app roles", async () => { vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(2); await expect(ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.MEMBER })).resolves.toEqual({ created: 0, roleCount: 2, }); expect(dbMock.role.findMany).not.toHaveBeenCalled(); expect(clearCacheKey).not.toHaveBeenCalled(); }); it("grants all scoped app roles to tenant owners and skips already assigned roles", async () => { vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(0); vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([{ id: "role_1" }, { id: "role_2" }] as never); vi.mocked(dbMock.userRole.findMany) .mockResolvedValueOnce([{ id: "existing_role_2", roleId: "role_2" }] as never) .mockResolvedValueOnce([] as never); vi.mocked(dbMock.userRole.createMany).mockResolvedValueOnce({ count: 1 } as never); await expect(ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.OWNER })).resolves.toEqual({ created: 1, roleCount: 2, }); expect(dbMock.role.findMany).toHaveBeenCalledWith({ where: { type: "app", OR: [{ tenantId: null }, { tenantId: "tenant_1" }] }, orderBy: { order: "asc" }, }); expect(dbMock.userRole.findMany).toHaveBeenCalledWith({ where: { userId: "user_1", tenantId: "tenant_1", roleId: { in: ["role_1", "role_2"] } }, }); expect(dbMock.userRole.createMany).toHaveBeenCalledWith({ data: [{ userId: "user_1", roleId: "role_1", tenantId: "tenant_1" }], skipDuplicates: true, }); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1"); }); it("clears role cache when every scoped app role is already assigned", async () => { vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(0); vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([{ id: "role_1" }] as never); vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([{ id: "existing_role_1", roleId: "role_1" }] as never); await expect(ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.ADMIN })).resolves.toEqual({ created: 0, roleCount: 1, }); expect(dbMock.userRole.createMany).not.toHaveBeenCalled(); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1"); }); it("grants only assign-to-new-users app roles to regular members", async () => { vi.mocked(dbMock.userRole.count).mockResolvedValueOnce(0); vi.mocked(dbMock.role.findMany).mockResolvedValueOnce([] as never); await ensureTenantUserAppRoles({ userId: "user_1", tenantId: "tenant_1", tenantUserType: TenantUserType.MEMBER }); expect(dbMock.role.findMany).toHaveBeenCalledWith({ where: { type: "app", OR: [{ tenantId: null }, { tenantId: "tenant_1" }], assignToNewUsers: true, }, orderBy: { order: "asc" }, }); }); it("does not duplicate an existing user role", async () => { vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce({ id: "ur_existing" } as never); await expect(createUserRole("user_1", "role_1", "tenant_1")).resolves.toEqual({ id: "ur_existing" }); expect(dbMock.userRole.create).not.toHaveBeenCalled(); expect(clearCacheKey).not.toHaveBeenCalled(); }); it("returns the concurrently-created user role when the unique assignment index wins the race", async () => { vi.mocked(dbMock.userRole.findFirst) .mockResolvedValueOnce(null) .mockResolvedValueOnce({ id: "ur_concurrent" } as never); vi.mocked(dbMock.userRole.create).mockRejectedValueOnce(Object.assign(new Error("Unique constraint failed"), { code: "P2002" }) as never); await expect(createUserRole("user_1", "role_admin", null)).resolves.toEqual({ id: "ur_concurrent" }); expect(dbMock.userRole.create).toHaveBeenCalledWith({ data: { userId: "user_1", roleId: "role_admin", tenantId: null } }); expect(dbMock.userRole.findFirst).toHaveBeenNthCalledWith(2, { where: { userId: "user_1", roleId: "role_admin", tenantId: null }, }); expect(clearCacheKey).not.toHaveBeenCalled(); }); it("rethrows failed user-role creation when the error is not a recoverable unique race", async () => { const error = new Error("database down"); vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null); vi.mocked(dbMock.userRole.create).mockRejectedValueOnce(error as never); await expect(createUserRole("user_1", "role_1", "tenant_1")).rejects.toBe(error); }); it("rethrows unique user-role creation races when the assignment cannot be found afterward", async () => { const error = Object.assign(new Error("Unique constraint failed"), { code: "P2002" }); vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null).mockResolvedValueOnce(null); vi.mocked(dbMock.userRole.create).mockRejectedValueOnce(error as never); await expect(createUserRole("user_1", "role_1", null)).rejects.toBe(error); }); it("fails closed when a required admin role is not configured", async () => { vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce(null); await expect(ensureAdminUserRoleByName("user_1", "SuperAdmin")).rejects.toThrow("Required admin role is not configured"); expect(dbMock.role.findFirst).toHaveBeenCalledWith({ where: { name: "SuperAdmin", type: "admin" }, select: { id: true }, }); expect(dbMock.userRole.create).not.toHaveBeenCalled(); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null"); }); it("grants a matching admin role by name with admin scope and invalidates the role cache", async () => { vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce({ id: "role_super_admin" } as never); vi.mocked(dbMock.userRole.findFirst).mockResolvedValue(null); vi.mocked(dbMock.userRole.create).mockResolvedValueOnce({ id: "ur_admin" } as never); await expect(ensureAdminUserRoleByName("user_1", "SuperAdmin")).resolves.toBeUndefined(); expect(dbMock.userRole.create).toHaveBeenCalledWith({ data: { userId: "user_1", roleId: "role_super_admin", tenantId: null }, }); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null"); }); it("revokes SuperAdmin on an SSO staff downgrade and invalidates the role cache", async () => { vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce({ id: "role_super_admin" } as never); vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 1 } as never); await expect(reconcileAdminUserRoleByName("user_1", "SuperAdmin", false)).resolves.toBe("revoked"); expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({ where: { userId: "user_1", roleId: "role_super_admin", tenantId: null }, }); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null"); }); it("keeps staff reconciliation safe when the SuperAdmin role is not configured", async () => { vi.mocked(dbMock.role.findFirst).mockResolvedValueOnce(null); await expect(reconcileAdminUserRoleByName("user_1", "SuperAdmin", false)).resolves.toBe("unchanged"); expect(dbMock.userRole.deleteMany).not.toHaveBeenCalled(); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null"); }); it("creates, bulk-creates, and deletes user roles while clearing tenant-specific caches", async () => { vi.mocked(dbMock.userRole.findFirst).mockResolvedValueOnce(null); vi.mocked(dbMock.userRole.create).mockResolvedValueOnce({ id: "ur_1" } as never); vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([] as never); vi.mocked(dbMock.userRole.createMany).mockResolvedValueOnce({ count: 3 } as never); vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 1 } as never); await createUserRole("user_1", "role_1", "tenant_1"); await createUserRoles("user_1", [ { id: "role_1", tenantId: "tenant_1" }, { id: "role_2", tenantId: "tenant_1" }, { id: "role_admin", tenantId: null }, ]); await deleteUserRole("user_1", "role_1", "tenant_1"); expect(dbMock.userRole.create).toHaveBeenCalledWith({ data: { userId: "user_1", roleId: "role_1", tenantId: "tenant_1" } }); expect(dbMock.userRole.createMany).toHaveBeenCalledWith({ data: [ { userId: "user_1", roleId: "role_1", tenantId: "tenant_1" }, { userId: "user_1", roleId: "role_2", tenantId: "tenant_1" }, { userId: "user_1", roleId: "role_admin", tenantId: null }, ], skipDuplicates: true, }); expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({ where: { userId: "user_1", roleId: "role_1", tenantId: "tenant_1" }, }); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1"); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null"); }); it("handles empty and already-existing bulk role assignments without writes", async () => { await expect(createUserRoles("user_1", [])).resolves.toEqual({ count: 0 }); vi.mocked(dbMock.userRole.findMany).mockResolvedValueOnce([{ userId: "user_1", roleId: "role_1", tenantId: null }] as never); await expect(createUserRoles("user_1", [{ id: "role_1", tenantId: null }])).resolves.toEqual({ count: 0 }); expect(dbMock.userRole.createMany).not.toHaveBeenCalled(); expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:null"); }); });