mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-19 06:23:32 +00:00
* fix: Run the Erasure Cascade in Admin User Deletion * refactor: Share Generation Stop Logic Between Self-Service and Admin Deletion * refactor: Move Admin Erasure Dependency Assembly Into packages/api * fix: Bind getCleanupJob When Waiting for Generation Persistence * test: Pin the Deletion Fence Before Admin Generation Stop * fix: Resolve the Erasure Target Config Fail Closed * fix: Carry the Target Profile Into Admin Erasure Storage Cleanup * fix: Keep the Erasure Target Contract Storage Neutral and Reuse the Loaded Identity * fix: Refuse New Generations Once Account Deletion Has Begun * fix: Enforce Account Deletion Admission Once in createJob and Narrow the Erasure File Type * fix: Install the Admission Guard in Every Entrypoint and Purge Refused Jobs * fix: Guarantee Refused Job Purge and Sanitize Admission Failures * fix: Route Remote Admission Through createJob and Keep Refusal Cleanup Sanitized * fix: Log Admission Cleanup Failures With Safe Error Metadata * refactor: Check Account Deletion Before Creating a Generation and Drain Twice * refactor: Order Admission Against the Deletion Marker Without a Grace Period * fix: Sanitize Post-Commit Admission Retirement Failures * fix: Wire Shared-Server MCP OAuth Cleanup Into Admin Erasure * fix: Scope Admin Erasure Lookups to the Target Tenant and Await Shared-Link Cleanup * fix: Resolve the Erasure Target Config Under the Target Tenant * fix: Run Admin Erasure OAuth Fencing in the Target Tenant * fix: Match the Split OAuth Invalidate and Disconnect Hooks in Admin Erasure * refactor: Inject the Tenant Executor Into the Erasure Resolver
767 lines
31 KiB
TypeScript
767 lines
31 KiB
TypeScript
import { Types } from 'mongoose';
|
|
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 name, email, and username with anchored prefix regex', 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.$or).toHaveLength(3);
|
|
expect(filter.$or[0]).toHaveProperty('name');
|
|
expect(filter.$or[1]).toHaveProperty('email');
|
|
expect(filter.$or[2]).toHaveProperty('username');
|
|
expect(filter.$or[0].name.source).toBe('^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.$or[0].name).toBeInstanceOf(RegExp);
|
|
expect(filter.$or[0].name.source).toBe('^test\\.user\\+1');
|
|
});
|
|
|
|
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();
|
|
});
|
|
});
|
|
});
|