432 lines
17 KiB
TypeScript
432 lines
17 KiB
TypeScript
// @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");
|
|
});
|
|
});
|