LibreChat/packages/api/src/admin/users.spec.ts
Marco Beretta de9d46fcd4
🔎 perf: Index-Bound Word-Prefix Search for Users and Groups (#16719)
* perf: Debounce People Picker Search

* perf: Index-Bound Word-Prefix Search for Users and Groups

Principal search and admin user search matched name, email and username
with case-insensitive regexes, which scan the whole users collection.
Users and groups now store lowercase, accent-folded token arrays derived
from each searchable field, indexed with tenantId, and searches match
anchored token prefixes. Schema middleware keeps the tokens in sync on
save, insertMany and update queries. Documents written before the tokens
existed stay findable through a fallback branch until
npm run migrate:search-tokens backfills them; startup warns while any
remain.

* perf: Build Search Token Indexes in the Backfill Migration

* fix: Reconcile Stale Search Tokens and Close Write-Path Gaps

The backfill now compares every document's tokens with its source fields and
repairs stale ones, so writes from an older server during a rolling deploy are
recoverable by rerunning it. Undefined assignments no longer clear tokens,
upsert inserts initialize every token field, every query word is required,
relevance scoring folds accents like the filter does, and the startup check
counts both collections in parallel and owns its error logging.

* perf: Drop the Second People Picker Debounce

SearchPicker already debounces query changes by 500ms; the extra 300ms delay
in UnifiedPeopleSearch stacked on top of it.

* fix: Match Nothing for Queries Over the Word Cap

Dropping the query word cap let one request build an unbounded filter. Restore
a 16 word cap, but a longer query now matches nothing instead of ignoring its
extra words, so a cap never produces a false positive.

* test: Cover Word-Prefix People Search and the Token Backfill End to End

* fix: Tokenize Fields an Upsert Copies From Its Filter

MongoDB copies equality conditions from an upsert's filter into the inserted
document, so their token fields now derive from that value instead of being
initialized empty.

* fix: Rank Accent-Folded User Matches Like the Search Filter

* test: Run the Token Backfill Without Blocking the Playwright Worker

* perf: Index Search Tokens Tenant First for Scoped Searches and Ignore Undefined Unsets

* test: Skip the Module-Scope Index Rebuild When the Scenario Runs the Backfill

* fix: Exit the Search Token Migration When Redis Clients Stay Open

* perf: Probe for Missing Search Tokens at Startup Instead of Counting Them

* test: Explain the Startup Probe the Warning Actually Issues

* fix: Keep Search Token Fields Out of Serialized Users and Groups

* fix: Keep the Admin Search Legacy Fallback Anchored at the Field Start

* fix: Score Groups Only on the Fields Search Matches

* perf: Start the Search Token Probe Alongside the Permission Checks

* fix: Warn at Startup When the Search Token Indexes Were Never Built

* fix: Score People Search Matches With the Filter's Word Separators

* perf: Check the Token Indexes Before Probing for Unmigrated Documents

* test: Drive the Failed Startup Probe Past the Index Check

* fix: Score People Search Matches Independently of Word Order
2026-10-16 22:41:37 +02:00

788 lines
32 KiB
TypeScript

import { Types } from 'mongoose';
import { buildUserSearchFilter } from '@librechat/data-schemas';
import { PrincipalType, SystemRoles } from 'librechat-data-provider';
import type { IUser, UserDeleteResult } from '@librechat/data-schemas';
import type { Response } from 'express';
import type { ServerRequest } from '~/types/http';
import type { AdminUsersDeps } from './users';
import { createAdminUsersHandlers } from './users';
import { eraseUserData } from '~/user/erasure';
jest.mock('~/user/erasure', () => ({
eraseUserData: jest.fn().mockResolvedValue(undefined),
}));
jest.mock('@librechat/data-schemas', () => ({
...jest.requireActual('@librechat/data-schemas'),
logger: { error: jest.fn(), warn: jest.fn(), info: jest.fn(), debug: jest.fn() },
}));
const validUserId = new Types.ObjectId().toString();
function mockUser(overrides: Partial<IUser> = {}): IUser {
return {
_id: new Types.ObjectId(),
name: 'Test User',
username: 'testuser',
email: 'test@example.com',
avatar: 'https://example.com/avatar.png',
role: 'USER',
provider: 'local',
createdAt: new Date('2025-01-01'),
updatedAt: new Date('2025-06-01'),
...overrides,
} as IUser;
}
function createReqRes(
overrides: {
params?: Record<string, string>;
query?: Record<string, string | string[]>;
user?: { _id?: Types.ObjectId; id?: string; role?: string; tenantId?: string };
} = {},
) {
const req = {
params: overrides.params ?? {},
query: overrides.query ?? {},
body: {},
user: overrides.user ?? { _id: new Types.ObjectId(), role: 'admin' },
} as unknown as ServerRequest;
const json = jest.fn();
const status = jest.fn().mockReturnValue({ json });
const res = { status, json } as unknown as Response;
return { req, res, status, json };
}
function createDeps(overrides: Partial<AdminUsersDeps> = {}): AdminUsersDeps {
return {
findUsers: jest.fn().mockResolvedValue([]),
countUsers: jest.fn().mockResolvedValue(0),
beginAgentTriggerUserDeletion: jest.fn().mockResolvedValue('acquired'),
cancelAgentTriggerUserDeletion: jest.fn().mockResolvedValue(true),
drainAgentTriggerDeliveriesForUser: jest.fn().mockResolvedValue(undefined),
prepareAgentTriggerUserPurge: jest.fn().mockResolvedValue(undefined),
cancelAgentTriggerUserPurge: jest.fn().mockResolvedValue(true),
purgeAgentTriggerDeliveriesForUser: jest.fn().mockResolvedValue(undefined),
revokeUserCodeEnvironmentWorkers: jest.fn().mockResolvedValue(0),
deleteUserById: jest
.fn()
.mockResolvedValue({ deletedCount: 1, message: 'User was deleted successfully.' }),
deleteUserCodeEnvironments: jest.fn().mockResolvedValue(0),
invalidateCodeEnvironmentConfigCache: jest.fn().mockResolvedValue(undefined),
deleteConfig: jest.fn().mockResolvedValue(null),
deleteAclEntries: jest.fn().mockResolvedValue(undefined),
deletePasskeysByUser: jest.fn().mockResolvedValue(0),
resolveErasure: jest.fn().mockResolvedValue({ deps: {} }),
cancelSubagentTasks: jest.fn().mockResolvedValue(undefined),
quiesceUserSchedules: jest.fn().mockResolvedValue(true),
restoreUserSchedulesFromDeletion: jest.fn().mockResolvedValue(undefined),
generationJobs: {
getAccountCleanupJobIdsForUser: jest.fn().mockResolvedValue([]),
getCleanupJob: jest.fn().mockResolvedValue(undefined),
abortJob: jest.fn().mockResolvedValue(null),
},
...overrides,
};
}
describe('createAdminUsersHandlers', () => {
beforeEach(() => {
jest.mocked(eraseUserData).mockClear();
});
describe('listUsers', () => {
it('returns paginated users with total count', async () => {
const users = [
mockUser({ _id: new Types.ObjectId(validUserId) }),
mockUser({ name: 'Other' }),
];
const deps = createDeps({
findUsers: jest.fn().mockResolvedValue(users),
countUsers: jest.fn().mockResolvedValue(2),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes();
await handlers.listUsers(req, res);
expect(status).toHaveBeenCalledWith(200);
const response = json.mock.calls[0][0];
expect(response.users).toHaveLength(2);
expect(response.total).toBe(2);
expect(response).toHaveProperty('limit');
expect(response).toHaveProperty('offset');
expect(response.users[0]).toHaveProperty('id');
expect(response.users[0]).toHaveProperty('name');
expect(response.users[0]).toHaveProperty('email');
expect(response.users[0]).toHaveProperty('role');
});
it('passes pagination params to findUsers and unfiltered count', async () => {
const findUsers = jest.fn().mockResolvedValue([]);
const countUsers = jest.fn().mockResolvedValue(0);
const deps = createDeps({ findUsers, countUsers });
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ query: { limit: '10', offset: '20' } });
await handlers.listUsers(req, res);
expect(findUsers).toHaveBeenCalledWith({}, expect.any(String), {
limit: 10,
offset: 20,
sort: { createdAt: -1 },
});
expect(countUsers).toHaveBeenCalledWith();
});
it('returns empty list when no users', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes();
await handlers.listUsers(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(json.mock.calls[0][0].users).toEqual([]);
expect(json.mock.calls[0][0].total).toBe(0);
});
it('returns 500 when findUsers throws', async () => {
const deps = createDeps({ findUsers: jest.fn().mockRejectedValue(new Error('db down')) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes();
await handlers.listUsers(req, res);
expect(status).toHaveBeenCalledWith(500);
expect(json).toHaveBeenCalledWith({ error: 'Failed to list users' });
});
it('returns 500 when countUsers throws', async () => {
const deps = createDeps({
countUsers: jest.fn().mockRejectedValue(new Error('count failed')),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes();
await handlers.listUsers(req, res);
expect(status).toHaveBeenCalledWith(500);
expect(json).toHaveBeenCalledWith({ error: 'Failed to list users' });
});
});
describe('searchUsers', () => {
it('returns matching users with total and capped flag', async () => {
const users = [mockUser()];
const deps = createDeps({ findUsers: jest.fn().mockResolvedValue(users) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: 'test' } });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(200);
const response = json.mock.calls[0][0];
expect(response.users).toHaveLength(1);
expect(response.total).toBe(1);
expect(response.capped).toBe(false);
expect(response.users[0]).toHaveProperty('id');
expect(response.users[0]).toHaveProperty('name');
expect(response.users[0]).toHaveProperty('email');
expect(response.users[0]).toHaveProperty('username');
});
it('sets capped to true when results hit the limit', async () => {
const users = Array.from({ length: 20 }, () => mockUser());
const deps = createDeps({ findUsers: jest.fn().mockResolvedValue(users) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, json } = createReqRes({ query: { q: 'test', limit: '20' } });
await handlers.searchUsers(req, res);
const response = json.mock.calls[0][0];
expect(response.total).toBe(20);
expect(response.capped).toBe(true);
});
it('searches the indexed word-prefix tokens of name, email, and username', async () => {
const findUsers = jest.fn().mockResolvedValue([]);
const deps = createDeps({ findUsers });
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ query: { q: 'Test' } });
await handlers.searchUsers(req, res);
const filter = findUsers.mock.calls[0][0];
expect(filter).toEqual(buildUserSearchFilter('Test', { legacyPrefix: true }));
expect(filter.$or).toEqual(
expect.arrayContaining([
{ nameTokens: /^test/ },
{ emailTokens: /^test/ },
{ usernameTokens: /^test/ },
]),
);
});
it('projects username in the field selection', async () => {
const findUsers = jest.fn().mockResolvedValue([]);
const deps = createDeps({ findUsers });
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ query: { q: 'test' } });
await handlers.searchUsers(req, res);
const projection = findUsers.mock.calls[0][1];
expect(projection).toContain('username');
});
it('escapes regex special characters in query', async () => {
const findUsers = jest.fn().mockResolvedValue([]);
const deps = createDeps({ findUsers });
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ query: { q: 'test.user+1' } });
await handlers.searchUsers(req, res);
const filter = findUsers.mock.calls[0][0];
expect(filter.$and[0].$or).toContainEqual({ emailTokens: /^test\.user\+1/ });
/** Documents awaiting the backfill keep the old anchored prefix match. */
expect(filter.$and[0].$or).toContainEqual({
nameTokens: { $exists: false },
name: /^test\.user\+1/i,
});
});
it('returns no users without querying when the query has nothing to match', async () => {
const findUsers = jest.fn();
const deps = createDeps({ findUsers });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: '\u0301\u0301' } });
await handlers.searchUsers(req, res);
expect(findUsers).not.toHaveBeenCalled();
expect(status).toHaveBeenCalledWith(200);
expect(json).toHaveBeenCalledWith({ users: [], total: 0, capped: false });
});
it('returns 400 when query is missing', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: {} });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith({ error: 'Query parameter "q" is required' });
});
it('returns 400 when query is empty string', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: '' } });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith({ error: 'Query parameter "q" is required' });
});
it('returns 400 when query is whitespace-only', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: ' ' } });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith({ error: 'Query parameter "q" is required' });
});
it('returns 400 when query is too short', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: 'a' } });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith({ error: 'Query must be at least 2 characters' });
});
it('returns 400 when query exceeds max length', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: 'a'.repeat(201) } });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith(
expect.objectContaining({ error: expect.stringContaining('200') }),
);
});
it('treats array query param as missing', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: ['foo', 'bar'] } });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith({ error: 'Query parameter "q" is required' });
});
it('passes limit to findUsers', async () => {
const findUsers = jest.fn().mockResolvedValue([mockUser()]);
const deps = createDeps({ findUsers });
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ query: { q: 'User', limit: '3' } });
await handlers.searchUsers(req, res);
expect(findUsers).toHaveBeenCalledWith(expect.any(Object), expect.any(String), {
limit: 3,
sort: { name: 1 },
});
});
it('caps limit at 50', async () => {
const findUsers = jest.fn().mockResolvedValue([]);
const deps = createDeps({ findUsers });
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ query: { q: 'User', limit: '100' } });
await handlers.searchUsers(req, res);
expect(findUsers).toHaveBeenCalledWith(expect.any(Object), expect.any(String), {
limit: 50,
sort: { name: 1 },
});
});
it('returns 500 on error', async () => {
const deps = createDeps({ findUsers: jest.fn().mockRejectedValue(new Error('db down')) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ query: { q: 'test' } });
await handlers.searchUsers(req, res);
expect(status).toHaveBeenCalledWith(500);
expect(json).toHaveBeenCalledWith({ error: 'Failed to search users' });
});
});
describe('deleteUser', () => {
it('deletes user and returns 200', async () => {
const result: UserDeleteResult = {
deletedCount: 1,
message: 'User was deleted successfully.',
};
const deps = createDeps({ deleteUserById: jest.fn().mockResolvedValue(result) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(json).toHaveBeenCalledWith({ message: 'User was deleted successfully.' });
expect(deps.beginAgentTriggerUserDeletion).toHaveBeenCalledWith(
validUserId,
expect.any(Date),
);
expect(deps.drainAgentTriggerDeliveriesForUser).toHaveBeenCalledWith(validUserId);
expect(deps.prepareAgentTriggerUserPurge).toHaveBeenCalledWith(
validUserId,
expect.any(Date),
undefined,
);
expect(deps.purgeAgentTriggerDeliveriesForUser).toHaveBeenCalledWith(validUserId);
expect(deps.cancelAgentTriggerUserPurge).not.toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserDeletion).not.toHaveBeenCalled();
});
it('returns fallback message when result.message is empty', async () => {
const result: UserDeleteResult = { deletedCount: 1, message: '' };
const deps = createDeps({ deleteUserById: jest.fn().mockResolvedValue(result) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(json).toHaveBeenCalledWith({ message: 'User deleted successfully' });
});
it('returns 403 when deleting own account', async () => {
const userId = new Types.ObjectId();
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({
params: { id: userId.toString() },
user: { _id: userId, role: 'admin' },
});
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(403);
expect(json).toHaveBeenCalledWith({ error: 'Cannot delete your own account' });
expect(deps.deleteUserById).not.toHaveBeenCalled();
});
it('returns 400 when deleting the last admin', async () => {
const targetId = new Types.ObjectId().toString();
const deps = createDeps({
findUsers: jest.fn().mockResolvedValue([mockUser({ role: SystemRoles.ADMIN })]),
countUsers: jest.fn().mockResolvedValue(1),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: targetId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith({ error: 'Cannot delete the last admin user' });
expect(deps.deleteUserById).not.toHaveBeenCalled();
expect(deps.countUsers).toHaveBeenCalledWith({ role: SystemRoles.ADMIN });
});
it('allows deleting an admin when other admins exist', async () => {
const targetId = new Types.ObjectId().toString();
const deps = createDeps({
findUsers: jest.fn().mockResolvedValue([mockUser({ role: SystemRoles.ADMIN })]),
countUsers: jest.fn().mockResolvedValue(3),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: targetId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(deps.deleteUserById).toHaveBeenCalledWith(targetId);
});
it('does not check admin count when target is a regular user', async () => {
const targetId = new Types.ObjectId().toString();
const deps = createDeps({
findUsers: jest.fn().mockResolvedValue([mockUser({ role: 'USER' })]),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: targetId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(deps.countUsers).not.toHaveBeenCalled();
});
it('cascades cleanup of Config, code environments, and AclEntries', async () => {
const result: UserDeleteResult = {
deletedCount: 1,
message: 'User was deleted successfully.',
};
const deps = createDeps({ deleteUserById: jest.fn().mockResolvedValue(result) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(deps.deleteConfig).toHaveBeenCalledWith(PrincipalType.USER, validUserId);
expect(deps.deleteUserCodeEnvironments).toHaveBeenCalledWith(expect.any(Types.ObjectId));
expect(deps.invalidateCodeEnvironmentConfigCache).toHaveBeenCalledWith(undefined);
expect(deps.deleteAclEntries).toHaveBeenCalledWith({
principalType: PrincipalType.USER,
principalId: expect.any(Types.ObjectId),
});
expect(deps.deletePasskeysByUser).toHaveBeenCalledWith(validUserId);
});
it('runs the shared erasure cascade for the target before removing the user', async () => {
const checkpointer = { ttl: 60 };
const erasureDeps = { marker: true };
const deps = createDeps({
findUsers: jest.fn().mockResolvedValue([mockUser({ role: 'USER', tenantId: 'tenant-1' })]),
resolveErasure: jest.fn().mockResolvedValue({ deps: erasureDeps, checkpointer }),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(deps.resolveErasure).toHaveBeenCalledWith(
expect.objectContaining({
id: validUserId,
role: 'USER',
tenantId: 'tenant-1',
idOnTheSource: null,
profile: expect.objectContaining({ role: 'USER' }),
}),
);
expect(eraseUserData).toHaveBeenCalledWith(
{ userId: validUserId, tenantId: 'tenant-1', checkpointer },
erasureDeps,
);
expect(jest.mocked(eraseUserData).mock.invocationCallOrder[0]).toBeLessThan(
jest.mocked(deps.deleteUserById).mock.invocationCallOrder[0],
);
});
it('keeps the user, and releases the fence, when the erasure cascade fails', async () => {
jest.mocked(eraseUserData).mockRejectedValueOnce(new Error('storage down'));
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(500);
expect(json).toHaveBeenCalledWith({ error: 'Failed to delete user' });
expect(deps.deleteUserById).not.toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserDeletion).toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserPurge).toHaveBeenCalled();
});
it('suspends schedules before erasing and restores them when the deletion fails', async () => {
jest.mocked(eraseUserData).mockRejectedValueOnce(new Error('storage down'));
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
const token = jest.mocked(deps.quiesceUserSchedules).mock.calls[0][1];
expect(status).toHaveBeenCalledWith(500);
expect(deps.restoreUserSchedulesFromDeletion).toHaveBeenCalledWith(validUserId, token);
expect(
jest.mocked(deps.restoreUserSchedulesFromDeletion).mock.invocationCallOrder[0],
).toBeLessThan(jest.mocked(deps.cancelAgentTriggerUserDeletion).mock.invocationCallOrder[0]);
});
it('takes the trigger deletion fence before listing generations to stop', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(
jest.mocked(deps.beginAgentTriggerUserDeletion).mock.invocationCallOrder[0],
).toBeLessThan(
jest.mocked(deps.generationJobs.getAccountCleanupJobIdsForUser).mock.invocationCallOrder[0],
);
});
it('does not erase when schedules cannot be confirmed stopped', async () => {
const deps = createDeps({ quiesceUserSchedules: jest.fn().mockResolvedValue(false) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(500);
expect(eraseUserData).not.toHaveBeenCalled();
expect(deps.deleteUserById).not.toHaveBeenCalled();
});
it('aborts the cleanup jobs of the target and refuses to erase when a stop is unconfirmed', async () => {
const abortJob = jest.fn().mockResolvedValue(null);
const deps = createDeps({
generationJobs: {
getAccountCleanupJobIdsForUser: jest.fn().mockResolvedValue(['s1', 's2']),
getCleanupJob: jest.fn(async (id: string) => ({
createdAt: 5,
metadata: { userId: id === 's1' ? validUserId : 'someone-else' },
})),
abortJob,
} as unknown as AdminUsersDeps['generationJobs'],
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(abortJob).toHaveBeenCalledTimes(1);
expect(abortJob).toHaveBeenCalledWith('s1', {
expectedCreatedAt: 5,
awaitProviderDrain: true,
});
expect(status).toHaveBeenCalledWith(500);
expect(eraseUserData).not.toHaveBeenCalled();
});
it('returns success even when cascade cleanup partially fails', async () => {
const result: UserDeleteResult = {
deletedCount: 1,
message: 'User was deleted successfully.',
};
const deps = createDeps({
deleteUserById: jest.fn().mockResolvedValue(result),
deleteConfig: jest.fn().mockRejectedValue(new Error('cleanup failed')),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(200);
expect(json).toHaveBeenCalledWith({ message: 'User was deleted successfully.' });
});
it('preserves code environment records when revocation marking fails', async () => {
const deps = createDeps({
revokeUserCodeEnvironmentWorkers: jest.fn().mockRejectedValue(new Error('mongo down')),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(deps.deleteUserById).toHaveBeenCalledWith(validUserId);
expect(deps.deleteUserCodeEnvironments).not.toHaveBeenCalled();
});
it('does not cascade when user is not found', async () => {
const result: UserDeleteResult = { deletedCount: 0, message: '' };
const deps = createDeps({ deleteUserById: jest.fn().mockResolvedValue(result) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(404);
expect(deps.deleteConfig).not.toHaveBeenCalled();
expect(deps.deleteUserCodeEnvironments).not.toHaveBeenCalled();
expect(deps.deleteAclEntries).not.toHaveBeenCalled();
expect(deps.purgeAgentTriggerDeliveriesForUser).not.toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserDeletion).toHaveBeenCalledWith(
validUserId,
expect.any(Date),
);
expect(deps.cancelAgentTriggerUserPurge).toHaveBeenCalledWith(validUserId, expect.any(Date));
});
it('returns 400 for invalid ObjectId', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: 'not-valid' } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(400);
expect(json).toHaveBeenCalledWith({ error: 'Invalid user ID format' });
});
it('returns 404 when user not found', async () => {
const result: UserDeleteResult = { deletedCount: 0, message: '' };
const deps = createDeps({ deleteUserById: jest.fn().mockResolvedValue(result) });
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(404);
expect(json).toHaveBeenCalledWith({ error: 'User not found' });
});
it('returns 500 on error', async () => {
const deps = createDeps({
deleteUserById: jest.fn().mockRejectedValue(new Error('db crash')),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(500);
expect(json).toHaveBeenCalledWith({ error: 'Failed to delete user' });
expect(deps.cancelAgentTriggerUserDeletion).toHaveBeenCalledWith(
validUserId,
expect.any(Date),
);
expect(deps.cancelAgentTriggerUserPurge).toHaveBeenCalledWith(validUserId, expect.any(Date));
expect(deps.purgeAgentTriggerDeliveriesForUser).not.toHaveBeenCalled();
});
it('does not delete while another deletion owns the trigger fence', async () => {
const deps = createDeps({
beginAgentTriggerUserDeletion: jest.fn().mockResolvedValue('in_progress'),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(409);
expect(json).toHaveBeenCalledWith({ error: 'User deletion is already in progress' });
expect(deps.drainAgentTriggerDeliveriesForUser).not.toHaveBeenCalled();
expect(deps.deleteUserById).not.toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserDeletion).not.toHaveBeenCalled();
});
it('returns not found without draining when the trigger fence principal is missing', async () => {
const deps = createDeps({
beginAgentTriggerUserDeletion: jest.fn().mockResolvedValue('missing'),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(404);
expect(json).toHaveBeenCalledWith({ error: 'User not found' });
expect(deps.drainAgentTriggerDeliveriesForUser).not.toHaveBeenCalled();
expect(deps.deleteUserById).not.toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserDeletion).not.toHaveBeenCalled();
});
it('drains before commit and purges only after the user is deleted', async () => {
const deps = createDeps();
const handlers = createAdminUsersHandlers(deps);
const { req, res } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
const beginOrder = (deps.beginAgentTriggerUserDeletion as jest.Mock).mock
.invocationCallOrder[0];
const prepareOrder = (deps.prepareAgentTriggerUserPurge as jest.Mock).mock
.invocationCallOrder[0];
const drainOrder = (deps.drainAgentTriggerDeliveriesForUser as jest.Mock).mock
.invocationCallOrder[0];
const deleteOrder = (deps.deleteUserById as jest.Mock).mock.invocationCallOrder[0];
const revokeCodeOrder = (deps.revokeUserCodeEnvironmentWorkers as jest.Mock).mock
.invocationCallOrder[0];
const deleteCodeOrder = (deps.deleteUserCodeEnvironments as jest.Mock).mock
.invocationCallOrder[0];
const purgeOrder = (deps.purgeAgentTriggerDeliveriesForUser as jest.Mock).mock
.invocationCallOrder[0];
expect(beginOrder).toBeLessThan(drainOrder);
expect(beginOrder).toBeLessThan(prepareOrder);
expect(prepareOrder).toBeLessThan(drainOrder);
expect(drainOrder).toBeLessThan(deleteOrder);
expect(deleteOrder).toBeLessThan(revokeCodeOrder);
expect(revokeCodeOrder).toBeLessThan(deleteCodeOrder);
expect(deleteOrder).toBeLessThan(purgeOrder);
});
it('leaves durable purge recovery armed when immediate post-commit cleanup fails', async () => {
const deps = createDeps({
purgeAgentTriggerDeliveriesForUser: jest.fn().mockRejectedValue(new Error('db down')),
});
const handlers = createAdminUsersHandlers(deps);
const { req, res, status, json } = createReqRes({ params: { id: validUserId } });
await handlers.deleteUser(req, res);
expect(status).toHaveBeenCalledWith(500);
expect(json).toHaveBeenCalledWith({ error: 'Failed to delete user' });
expect(deps.deleteUserById).toHaveBeenCalledWith(validUserId);
expect(deps.prepareAgentTriggerUserPurge).toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserPurge).not.toHaveBeenCalled();
expect(deps.cancelAgentTriggerUserDeletion).not.toHaveBeenCalled();
});
});
});