LibreChat/api/server/routes/accessPermissions.directory.test.js
lia-by-librechat[bot] ea8c133c0b
🥸 fix: Resolve Directory Principals Through Trusted Integration Data (#17825)
* 🥸 fix: Resolve Directory Principals Through Trusted Integration Data

* fix: Verify Permission Principals Concurrently and Preserve Stored Groups

* fix: Refresh Stored Directory Group Membership Before Sharing

* fix: Preserve Directory Membership and Surface Principal Failures

* fix: Stage Principal Reads Before Bounded Permission Persistence

* test: Classify Historical Code Capability Name Expansion

* fix: Bound Directory Verification and Propagate Graph Denials

* test: Await Principal Collections Before Transaction Verification

* test: Isolate Theme Paint Measurements From DOM Trace Capture

---------

Co-authored-by: Lia <lia@librechat.ai>
2026-11-10 09:22:08 -05:00

801 lines
30 KiB
JavaScript

const express = require('express');
const request = require('supertest');
const mongoose = require('mongoose');
const { MongoMemoryServer } = require('mongodb-memory-server');
const { createModels, tenantStorage } = require('@librechat/data-schemas');
const {
SystemRoles,
ResourceType,
AccessRoleIds,
PrincipalType,
PermissionTypes,
PermissionBits,
} = require('librechat-data-provider');
let mockDirectoryConfig = {};
jest.mock('~/server/middleware', () => ({
requireJwtAuth: (_req, _res, next) => next(),
checkBan: (_req, _res, next) => next(),
uaParser: (_req, _res, next) => next(),
canAccessResource: jest.requireActual('~/server/middleware/accessResources/canAccessResource')
.canAccessResource,
configMiddleware: (req, _res, next) => {
req.config = mockDirectoryConfig;
next();
},
}));
jest.mock('~/server/services/Config', () => ({}));
jest.mock('~/server/services/GraphApiService', () => ({
...jest.requireActual('~/server/services/GraphApiService'),
createGraphClient: jest.fn(),
}));
jest.mock('~/models', () => ({
...jest.requireActual('~/models'),
getRoleByName: jest.fn(),
}));
const db = require('~/models');
const { createGraphClient } = require('~/server/services/GraphApiService');
const { grantPermission, checkPermission } = require('~/server/services/PermissionService');
const router = require('./accessPermissions');
const sourceId = '767f2e31-cd94-4247-909e-64b6b104e1f0';
const forged = {
type: PrincipalType.USER,
source: 'entra',
name: 'Forged Name',
email: 'forged@example.com',
idOnTheSource: sourceId,
accessRoleId: AccessRoleIds.SHARED_LINK_VIEWER,
};
describe('Shared-link directory principal provisioning', () => {
let mongoServer;
let app;
let owner;
let resourceId;
let graphGet;
let graphMembers;
let graphOwners;
let User;
let Group;
let AclEntry;
let requestTenant;
const originalEnv = {
USE_ENTRA_ID_FOR_PEOPLE_SEARCH: process.env.USE_ENTRA_ID_FOR_PEOPLE_SEARCH,
OPENID_REUSE_TOKENS: process.env.OPENID_REUSE_TOKENS,
ENTRA_ID_INCLUDE_OWNERS_AS_MEMBERS: process.env.ENTRA_ID_INCLUDE_OWNERS_AS_MEMBERS,
};
beforeAll(async () => {
mongoServer = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });
await mongoose.connect(mongoServer.getUri());
createModels(mongoose);
({ User, Group, AclEntry } = mongoose.models);
await db.seedDefaultRoles();
app = express();
app.use(express.json());
app.use((_req, _res, next) => tenantStorage.run({ tenantId: requestTenant }, next));
app.use((req, _res, next) => {
req.user = { ...owner.toObject(), id: owner._id.toString() };
next();
});
app.use('/api/permissions', router);
});
afterAll(async () => {
for (const [key, value] of Object.entries(originalEnv)) {
if (value === undefined) {
delete process.env[key];
} else {
process.env[key] = value;
}
}
await mongoose.disconnect();
await mongoServer?.stop();
});
beforeEach(async () => {
jest.clearAllMocks();
requestTenant = undefined;
mockDirectoryConfig = {};
await Promise.all([User.deleteMany({}), Group.deleteMany({}), AclEntry.deleteMany({})]);
process.env.USE_ENTRA_ID_FOR_PEOPLE_SEARCH = 'true';
process.env.OPENID_REUSE_TOKENS = 'true';
process.env.ENTRA_ID_INCLUDE_OWNERS_AS_MEMBERS = 'false';
owner = await User.create({
name: 'Link Owner',
email: 'owner@example.com',
provider: 'openid',
openidId: 'owner-subject',
role: SystemRoles.USER,
});
const link = await mongoose.models.SharedLink.create({
conversationId: 'test-conversation',
user: owner._id.toString(),
});
resourceId = link._id;
await grantPermission({
principalType: PrincipalType.USER,
principalId: owner._id,
resourceType: ResourceType.SHARED_LINK,
resourceId,
accessRoleId: AccessRoleIds.SHARED_LINK_OWNER,
grantedBy: owner._id,
});
db.getRoleByName.mockResolvedValue({
permissions: {
[PermissionTypes.SHARED_LINKS]: { USE: true, SHARE: true, SHARE_PUBLIC: true },
[PermissionTypes.AGENTS]: { USE: true, SHARE: true, SHARE_PUBLIC: true },
},
});
graphGet = jest.fn().mockResolvedValue(null);
graphMembers = jest.fn().mockResolvedValue({
value: [{ id: 'trusted-member', '@odata.type': '#microsoft.graph.user' }],
});
graphOwners = jest.fn().mockResolvedValue({ value: [] });
createGraphClient.mockResolvedValue({
api: (path) => {
const request = {
options: () => request,
middlewareOptions: () => request,
select: () => ({
get: () => graphGet(path),
top: () => ({
get: () => (path.includes('/owners') ? graphOwners(path) : graphMembers(path)),
}),
}),
};
return request;
},
});
});
afterEach(() => jest.restoreAllMocks());
const update = (
principals,
token = 'test-access-token',
extra = {},
resourceType = ResourceType.SHARED_LINK,
) => {
const call = request(app).put(`/api/permissions/${resourceType}/${resourceId}`);
if (token) {
call.set('Authorization', `Bearer ${token}`);
}
return call.send({ updated: principals, removed: [], ...extra });
};
it.each(['disabled', 'token reuse disabled', 'local login', 'missing subject', 'missing token'])(
'does not create accounts or disclose users when integration is unavailable: %s',
async (unavailable) => {
const existing = await User.create({
name: 'Private Existing User',
email: 'private@example.com',
provider: 'local',
idOnTheSource: 'existing-source-id',
});
if (unavailable === 'disabled') {
process.env.USE_ENTRA_ID_FOR_PEOPLE_SEARCH = 'false';
} else if (unavailable === 'token reuse disabled') {
process.env.OPENID_REUSE_TOKENS = 'false';
} else if (unavailable === 'local login') {
owner.provider = 'local';
} else if (unavailable === 'missing subject') {
owner.openidId = undefined;
}
const probes = [
forged,
{ ...forged, email: existing.email },
{ ...forged, idOnTheSource: existing.idOnTheSource },
{ ...forged, type: PrincipalType.GROUP },
{ ...forged, id: { $ne: null } },
{ ...forged, idOnTheSource: { $ne: null } },
];
const response = await update(probes, unavailable === 'missing token' ? null : undefined);
expect(response.status).toBe(200);
expect(response.body.results.principals).toEqual([]);
expect(JSON.stringify(response.body)).not.toContain(existing._id.toString());
expect(JSON.stringify(response.body)).not.toContain(existing.name);
expect(await User.countDocuments()).toBe(2);
expect(await Group.countDocuments()).toBe(0);
expect(await AclEntry.countDocuments()).toBe(1);
expect(createGraphClient).not.toHaveBeenCalled();
},
);
it.each([
[403, 502],
[404, 200],
])('fails closed without disclosure on Graph status %i', async (statusCode, status) => {
const existing = await User.create({ email: forged.email, name: 'Private User' });
graphGet.mockRejectedValue(Object.assign(new Error('Private upstream detail'), { statusCode }));
const response = await update([forged]);
expect(response.status).toBe(status);
if (status === 200) expect(response.body.results.principals).toEqual([]);
else expect(response.body.code).toBe('DIRECTORY_VERIFICATION_UNAVAILABLE');
expect(JSON.stringify(response.body)).not.toContain(existing._id.toString());
expect(JSON.stringify(response.body)).not.toContain('Private upstream detail');
expect(await User.countDocuments()).toBe(2);
expect(await AclEntry.countDocuments()).toBe(1);
});
it('returns a safe directory failure for an external group denied by Graph', async () => {
graphGet.mockRejectedValue(
Object.assign(new Error('Private consent details'), { statusCode: 403 }),
);
const response = await update([{ ...forged, type: PrincipalType.GROUP }]);
expect(response.status).toBe(502);
expect(response.body.code).toBe('DIRECTORY_VERIFICATION_UNAVAILABLE');
expect(await Group.countDocuments()).toBe(0);
expect(await AclEntry.countDocuments()).toBe(1);
expect(JSON.stringify(response.body)).not.toContain('Private consent');
});
it('preserves sharing when People resolves an organizational user after users is denied', async () => {
graphGet.mockRejectedValueOnce(
Object.assign(new Error('Missing User.Read.All'), { statusCode: 403 }),
);
graphGet.mockResolvedValueOnce({
id: sourceId,
displayName: 'Trusted',
personType: { subclass: 'OrganizationUser' },
scoredEmailAddresses: [{ address: 'trusted@example.com' }],
});
const response = await update([forged]);
expect(response.status).toBe(200);
expect(response.body.results.principals).toHaveLength(1);
expect(await User.findOne({ email: 'trusted@example.com' })).not.toBeNull();
});
it.each(['client', 'identity', 'members', 'owners', 'later page'])(
'returns a retryable failure with no writes when %s stalls past the configured deadline',
async (phase) => {
mockDirectoryConfig = {
timeouts: { directoryMs: 20 },
concurrency: { permissionPrincipalLookups: 1 },
};
const group = await Group.create({
name: 'Stored',
source: 'entra',
idOnTheSource: sourceId,
memberIds: ['kept-member'],
});
const stalled = () => new Promise(() => undefined);
if (phase === 'client') createGraphClient.mockImplementationOnce(stalled);
if (phase === 'identity') graphGet.mockImplementationOnce(stalled);
if (phase === 'members') graphMembers.mockImplementationOnce(stalled);
if (phase === 'owners') {
process.env.ENTRA_ID_INCLUDE_OWNERS_AS_MEMBERS = 'true';
graphOwners.mockImplementationOnce(stalled);
}
if (phase === 'later page') {
graphMembers.mockResolvedValueOnce({
value: [],
'@odata.nextLink': `https://graph.microsoft.com/v1.0/groups/${sourceId}/transitiveMembers?page=2`,
});
graphMembers.mockImplementationOnce(stalled);
}
const persist = jest.spyOn(db, 'persistPermissionPrincipals');
const response = await update([
phase === 'client' || phase === 'identity'
? forged
: { ...forged, type: PrincipalType.GROUP, id: group._id.toString() },
]);
expect(response.status).toBe(502);
expect(response.body).toEqual({
error: 'Failed to update permissions',
details: 'Directory identity verification failed',
code: 'DIRECTORY_VERIFICATION_UNAVAILABLE',
});
expect(persist).not.toHaveBeenCalled();
expect(await User.countDocuments()).toBe(1);
expect(await Group.countDocuments()).toBe(1);
expect((await Group.findById(group._id).lean()).memberIds).toEqual(['kept-member']);
expect(await AclEntry.countDocuments()).toBe(1);
},
);
it.each(['client', 'lookup'])(
'returns a safe failure without ACL changes on a provider %s outage',
async (failure) => {
const existing = await User.create({ email: forged.email, name: 'Private User' });
const error = Object.assign(new Error('Private upstream detail'), { statusCode: 503 });
if (failure === 'client') {
createGraphClient.mockRejectedValueOnce(error);
} else {
graphGet.mockRejectedValue(error);
}
const response = await update(
[
{
type: PrincipalType.USER,
id: existing._id.toString(),
accessRoleId: AccessRoleIds.SHARED_LINK_VIEWER,
},
forged,
],
undefined,
{ public: true, publicAccessRoleId: AccessRoleIds.SHARED_LINK_VIEWER },
);
expect(response.status).toBe(502);
expect(response.body).toEqual({
error: 'Failed to update permissions',
details: 'Directory identity verification failed',
code: 'DIRECTORY_VERIFICATION_UNAVAILABLE',
});
expect(JSON.stringify(response.body)).not.toContain(existing._id.toString());
expect(await User.countDocuments()).toBe(2);
expect(await AclEntry.countDocuments()).toBe(1);
},
);
it('does not provision or disclose a user for a nonexistent source ID', async () => {
const existing = await User.create({ email: forged.email, name: 'Private User' });
const response = await update([forged]);
expect(response.status).toBe(200);
expect(response.body.results.principals).toEqual([]);
expect(JSON.stringify(response.body)).not.toContain(existing._id.toString());
expect(await User.countDocuments()).toBe(2);
expect(await AclEntry.countDocuments()).toBe(1);
});
it('creates a directory placeholder from canonical metadata, not a forged existing-user email', async () => {
const existing = await User.create({
email: forged.email,
name: 'Private User',
provider: 'local',
});
graphGet.mockResolvedValue({
id: sourceId,
displayName: 'Trusted Name',
mail: 'Trusted@Example.com',
});
const response = await update([forged]);
expect(response.status).toBe(200);
expect(response.body.results.principals).toHaveLength(1);
const created = await User.findOne({ idOnTheSource: sourceId }).lean();
expect(created).toMatchObject({
name: 'Trusted Name',
email: 'trusted@example.com',
provider: 'openid',
emailVerified: false,
});
expect(response.body.results.principals[0].id).toBe(created._id.toString());
expect(JSON.stringify(response.body)).not.toContain(existing._id.toString());
expect((await User.findById(existing._id).lean()).idOnTheSource).toBeUndefined();
expect(await AclEntry.countDocuments()).toBe(2);
});
it('shares with an existing user by canonical email without changing its authentication identity', async () => {
const existing = await User.create({
email: 'trusted@example.com',
name: 'Local User',
provider: 'local',
});
graphGet.mockResolvedValue({
id: sourceId,
displayName: 'Trusted Name',
mail: 'Trusted@Example.com',
});
const response = await update([forged]);
expect(response.status).toBe(200);
expect(response.body.results.principals[0].id).toBe(existing._id.toString());
const unchanged = await User.findById(existing._id).lean();
expect(unchanged.provider).toBe('local');
expect(unchanged.idOnTheSource).toBeUndefined();
expect(await User.countDocuments()).toBe(2);
});
it('creates external groups using trusted Graph metadata and members', async () => {
graphGet.mockResolvedValue({
id: sourceId,
displayName: 'Trusted Group',
mail: 'Group@Example.com',
description: 'Trusted description',
});
const response = await update([
{ ...forged, type: PrincipalType.GROUP, description: 'Forged description' },
]);
expect(response.status).toBe(200);
const group = await Group.findOne({ idOnTheSource: sourceId }).lean();
expect(group).toMatchObject({
name: 'Trusted Group',
email: 'group@example.com',
description: 'Trusted description',
memberIds: ['trusted-member'],
});
expect(response.body.results.principals[0].id).toBe(group._id.toString());
expect(await User.countDocuments()).toBe(1);
});
it('refreshes persisted Entra membership from its stored ID before sharing a new link', async () => {
const removed = await User.create({
email: 'removed@example.com',
provider: 'openid',
idOnTheSource: 'removed-member',
});
const active = await User.create({
email: 'active@example.com',
provider: 'openid',
idOnTheSource: 'active-member',
});
const group = await Group.create({
name: 'Stored Directory Group',
source: 'entra',
idOnTheSource: sourceId,
memberIds: ['removed-member', 'active-member'],
});
await db.getUserPrincipals({ userId: removed._id.toString(), role: SystemRoles.USER });
graphMembers.mockResolvedValueOnce({
value: [{ id: 'active-member', '@odata.type': '#microsoft.graph.user' }],
});
const response = await update([
{
...forged,
type: PrincipalType.GROUP,
id: group._id.toString(),
idOnTheSource: 'forged-group-id',
},
]);
expect(response.status).toBe(200);
expect(graphMembers).toHaveBeenCalledWith(`/groups/${sourceId}/transitiveMembers`);
expect((await Group.findById(group._id).lean()).memberIds).toEqual(['active-member']);
const permission = {
role: SystemRoles.USER,
resourceType: ResourceType.SHARED_LINK,
resourceId,
requiredPermission: PermissionBits.VIEW,
};
await expect(checkPermission({ ...permission, userId: removed._id.toString() })).resolves.toBe(
false,
);
await expect(checkPermission({ ...permission, userId: active._id.toString() })).resolves.toBe(
true,
);
expect(createGraphClient).toHaveBeenCalledTimes(1);
});
it.each(['disabled', 'local login', 'token reuse disabled', 'missing token'])(
'shares with persisted Entra groups without Graph when %s',
async (unavailable) => {
const group = await Group.create({
name: 'Stored Directory Group',
source: 'entra',
idOnTheSource: sourceId,
memberIds: ['stored-member'],
});
if (unavailable === 'disabled') {
process.env.USE_ENTRA_ID_FOR_PEOPLE_SEARCH = 'false';
} else if (unavailable === 'local login') {
owner.provider = 'local';
} else if (unavailable === 'token reuse disabled') {
process.env.OPENID_REUSE_TOKENS = 'false';
}
const response = await update(
[
{
...forged,
type: PrincipalType.GROUP,
id: group._id.toString(),
idOnTheSource: 'forged-source',
},
],
unavailable === 'missing token' ? null : undefined,
);
expect(response.status).toBe(200);
expect(response.body.results.principals).toHaveLength(1);
expect(response.body.results.principals[0].id).toBe(group._id.toString());
expect(await AclEntry.countDocuments()).toBe(2);
expect(await Group.findById(group._id).lean()).toMatchObject({
name: group.name,
idOnTheSource: sourceId,
memberIds: ['stored-member'],
});
expect(createGraphClient).not.toHaveBeenCalled();
},
);
it.each([new mongoose.Types.ObjectId().toString(), { $ne: null }])(
'rejects a nonexistent or malformed local Entra group ID without provisioning: %j',
async (id) => {
const response = await update([{ ...forged, type: PrincipalType.GROUP, id }]);
expect(response.status).toBe(200);
expect(response.body.results.principals).toEqual([]);
expect(await Group.countDocuments()).toBe(0);
expect(await AclEntry.countDocuments()).toBe(1);
expect(createGraphClient).not.toHaveBeenCalled();
},
);
it('rejects a persisted Entra group from another tenant', async () => {
const group = await Group.create({
name: 'Private Directory Group',
source: 'entra',
tenantId: 'other-tenant',
idOnTheSource: sourceId,
});
requestTenant = 'current-tenant';
await tenantStorage.run({ tenantId: requestTenant }, async () => {
await db.seedDefaultRoles();
owner = await User.create({ email: 'tenant-owner@example.com', role: SystemRoles.USER });
const link = await mongoose.models.SharedLink.create({
conversationId: 'tenant-conversation',
user: owner._id.toString(),
});
resourceId = link._id;
await grantPermission({
principalType: PrincipalType.USER,
principalId: owner._id,
resourceType: ResourceType.SHARED_LINK,
resourceId,
accessRoleId: AccessRoleIds.SHARED_LINK_OWNER,
grantedBy: owner._id,
});
});
const response = await update([
{ ...forged, type: PrincipalType.GROUP, id: group._id.toString() },
]);
expect(response.status).toBe(200);
expect(response.body.results.principals).toEqual([]);
expect(JSON.stringify(response.body)).not.toContain(group.name);
expect(await AclEntry.countDocuments({ resourceId })).toBe(1);
expect(createGraphClient).not.toHaveBeenCalled();
});
it('applies a stored Entra group permission downgrade without Graph', async () => {
owner.provider = 'local';
const group = await Group.create({
name: 'Stored Directory Group',
source: 'entra',
idOnTheSource: sourceId,
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: owner._id,
resourceType: ResourceType.AGENT,
resourceId,
accessRoleId: AccessRoleIds.AGENT_OWNER,
grantedBy: owner._id,
});
await grantPermission({
principalType: PrincipalType.GROUP,
principalId: group._id,
resourceType: ResourceType.AGENT,
resourceId,
accessRoleId: AccessRoleIds.AGENT_EDITOR,
grantedBy: owner._id,
});
const response = await update(
[
{
...forged,
type: PrincipalType.GROUP,
id: group._id.toString(),
accessRoleId: AccessRoleIds.AGENT_VIEWER,
},
],
null,
{},
ResourceType.AGENT,
);
expect(response.status).toBe(200);
expect(response.body.results.principals[0]).toMatchObject({
id: group._id.toString(),
accessRoleId: AccessRoleIds.AGENT_VIEWER,
});
const entry = await AclEntry.findOne({ resourceId, principalId: group._id }).lean();
const viewer = await db.findRoleByIdentifier(AccessRoleIds.AGENT_VIEWER);
expect(entry.permBits).toBe(viewer.permBits);
expect(createGraphClient).not.toHaveBeenCalled();
});
it.each(['client', 'members', 'owners', 'later page'])(
'leaves persisted group membership and unrelated ACLs unchanged on %s failure',
async (failure) => {
const group = await Group.create({
name: 'Stored Group',
source: 'entra',
idOnTheSource: sourceId,
memberIds: ['kept-member'],
});
const otherResource = new mongoose.Types.ObjectId();
await grantPermission({
principalType: PrincipalType.GROUP,
principalId: group._id,
resourceType: ResourceType.SHARED_LINK,
resourceId: otherResource,
accessRoleId: AccessRoleIds.SHARED_LINK_VIEWER,
grantedBy: owner._id,
});
const before = await AclEntry.find({}).lean();
const error = new Error('Private Graph diagnostics');
if (failure === 'client') {
createGraphClient.mockRejectedValueOnce(error);
} else if (failure === 'owners') {
process.env.ENTRA_ID_INCLUDE_OWNERS_AS_MEMBERS = 'true';
graphOwners.mockRejectedValueOnce(error);
} else if (failure === 'later page') {
graphMembers.mockResolvedValueOnce({
value: [{ id: 'partial-member', '@odata.type': '#microsoft.graph.user' }],
'@odata.nextLink': `https://graph.microsoft.com/v1.0/groups/${sourceId}/transitiveMembers?$skiptoken=next`,
});
graphMembers.mockRejectedValueOnce(error);
} else {
graphMembers.mockRejectedValueOnce(error);
}
const response = await update(
[{ ...forged, type: PrincipalType.GROUP, id: group._id.toString() }],
undefined,
{ public: true, publicAccessRoleId: AccessRoleIds.SHARED_LINK_VIEWER },
);
expect(response.status).toBe(502);
expect(response.body).toEqual({
error: 'Failed to update permissions',
details: 'Directory identity verification failed',
code: 'DIRECTORY_VERIFICATION_UNAVAILABLE',
});
expect((await Group.findById(group._id).lean()).memberIds).toEqual(['kept-member']);
expect(await AclEntry.find({}).lean()).toEqual(before);
},
);
it('persists a genuinely empty group snapshot when Graph succeeds', async () => {
const group = await Group.create({
name: 'Stored Group',
source: 'entra',
idOnTheSource: sourceId,
memberIds: ['former-member'],
});
graphMembers.mockResolvedValueOnce({ value: [] });
const response = await update([
{ ...forged, type: PrincipalType.GROUP, id: group._id.toString() },
]);
expect(response.status).toBe(200);
expect((await Group.findById(group._id).lean()).memberIds).toEqual([]);
});
it.each(['findPermissionUser', 'findPermissionGroup', 'persistPermissionPrincipals'])(
'returns a sanitized failure without ACL changes when %s fails',
async (method) => {
const group = await Group.create({
name: 'Stored Group',
source: 'entra',
idOnTheSource: sourceId,
memberIds: ['kept-member'],
});
const local = await User.create({ email: 'local-sharing@example.com' });
graphGet.mockResolvedValue({
id: sourceId,
displayName: 'Trusted',
mail: 'trusted@example.com',
});
const recipient = { ...forged };
if (method === 'findPermissionGroup' || method === 'persistPermissionPrincipals') {
recipient.type = PrincipalType.GROUP;
recipient.id = group._id.toString();
}
jest.spyOn(db, method).mockRejectedValueOnce(new Error('Private database diagnostics'));
const response = await update(
[
recipient,
{
type: PrincipalType.USER,
id: local._id.toString(),
accessRoleId: AccessRoleIds.SHARED_LINK_VIEWER,
},
],
undefined,
{ public: true, publicAccessRoleId: AccessRoleIds.SHARED_LINK_VIEWER },
);
expect(response.status).toBe(500);
expect(response.body).toEqual({
error: 'Failed to update permissions',
details: 'Principal preparation failed',
code: 'PRINCIPAL_PREPARATION_FAILED',
});
expect(await AclEntry.countDocuments()).toBe(1);
expect((await Group.findById(group._id).lean()).memberIds).toEqual(['kept-member']);
},
);
it.each(['members', 'database'])(
'does not persist a staged refresh or new account when a later %s read fails',
async (failure) => {
const group = await Group.create({
name: 'Existing',
source: 'entra',
idOnTheSource: sourceId,
memberIds: ['kept-member'],
});
const failing = await Group.create({
name: 'Later',
source: 'entra',
idOnTheSource: 'failing-group',
memberIds: ['other-member'],
});
graphGet.mockResolvedValue({
id: 'new-user',
displayName: 'New User',
mail: 'new-user@example.com',
});
let release;
const blocked = new Promise((resolve) => {
release = resolve;
});
graphMembers.mockImplementation(async (path) => {
if (path.includes('failing-group')) {
await blocked;
throw new Error('Private provider failure');
}
return { value: [{ id: 'new-member', '@odata.type': '#microsoft.graph.user' }] };
});
if (failure === 'database') {
const find = db.findPermissionGroup;
jest.spyOn(db, 'findPermissionGroup').mockImplementation(async (query) => {
if (query.id === failing._id.toString()) {
await blocked;
throw new Error('Private database failure');
}
return find(query);
});
}
const persist = jest.spyOn(db, 'persistPermissionPrincipals');
const pending = update([
{ ...forged, idOnTheSource: 'new-user' },
{ ...forged, type: PrincipalType.GROUP, id: group._id.toString() },
{ ...forged, type: PrincipalType.GROUP, id: failing._id.toString() },
]).then((response) => response);
await new Promise((resolve) => setTimeout(resolve, 50));
expect(persist).not.toHaveBeenCalled();
release();
const response = await pending;
expect(response.status).toBe(failure === 'database' ? 500 : 502);
expect(persist).not.toHaveBeenCalled();
expect(await User.findOne({ email: 'new-user@example.com' })).toBeNull();
expect((await Group.findById(group._id).lean()).memberIds).toEqual(['kept-member']);
expect((await Group.findById(failing._id).lean()).memberIds).toEqual(['other-member']);
expect(await AclEntry.countDocuments()).toBe(1);
},
);
it('preserves local user, local group, role, public sharing, and revocation without Entra', async () => {
process.env.USE_ENTRA_ID_FOR_PEOPLE_SEARCH = 'false';
const localUser = await User.create({ email: 'local@example.com', name: 'Local User' });
const localGroup = await Group.create({ name: 'Local Group', source: 'local' });
const response = await update(
[
{
type: PrincipalType.USER,
id: localUser._id.toString(),
source: 'local',
accessRoleId: AccessRoleIds.SHARED_LINK_VIEWER,
},
{
type: PrincipalType.GROUP,
id: localGroup._id.toString(),
source: 'local',
accessRoleId: AccessRoleIds.SHARED_LINK_VIEWER,
},
{
type: PrincipalType.ROLE,
id: SystemRoles.USER,
accessRoleId: AccessRoleIds.SHARED_LINK_VIEWER,
},
],
null,
{ public: true, publicAccessRoleId: AccessRoleIds.SHARED_LINK_VIEWER },
);
expect(response.status).toBe(200);
expect(response.body.results.principals).toHaveLength(4);
expect(await AclEntry.countDocuments()).toBe(5);
const revoked = await update([], null, {
removed: [{ type: PrincipalType.USER, id: localUser._id.toString() }],
public: false,
});
expect(revoked.status).toBe(200);
expect(await AclEntry.countDocuments()).toBe(3);
expect(createGraphClient).not.toHaveBeenCalled();
});
});