mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-18 14:08:21 +00:00
2325 lines
85 KiB
JavaScript
2325 lines
85 KiB
JavaScript
const express = require('express');
|
||
const request = require('supertest');
|
||
|
||
const MOCKS = '../__test-utils__/convos-route-mocks';
|
||
jest.mock('~/server/services/Config/app', () => ({ getAppConfig: jest.fn() }));
|
||
const {
|
||
archiveAllHandler,
|
||
generationJobManager,
|
||
moderateText,
|
||
moderatedTexts,
|
||
messageIpLimiter,
|
||
messageUserLimiter,
|
||
subagentActivityHandlerInputs,
|
||
checkpointRows,
|
||
resetCheckpointRows,
|
||
} = require(MOCKS);
|
||
|
||
const priorLimitMessageIp = process.env.LIMIT_MESSAGE_IP;
|
||
const priorLimitMessageUser = process.env.LIMIT_MESSAGE_USER;
|
||
process.env.LIMIT_MESSAGE_IP = 'true';
|
||
process.env.LIMIT_MESSAGE_USER = 'true';
|
||
|
||
const checkpointNamespace = (id) =>
|
||
`${require(MOCKS).ownerPrefix('test-user-123')}00000000-0000-4000-8000-${String(id).padStart(12, '0')}`;
|
||
|
||
jest.mock('@librechat/agents', () => require(MOCKS).agents());
|
||
jest.mock('@librechat/api', () =>
|
||
require(MOCKS).api({
|
||
createContentFilter: jest.fn((options) => (req, res, next) => {
|
||
const extracted = [...options.extract(req)];
|
||
if (JSON.stringify(extracted).includes('BLOCK-CONTROL')) {
|
||
return res.status(400).json({ error: 'content_filter_block' });
|
||
}
|
||
next();
|
||
}),
|
||
extractStoredMessageContent: jest.fn((input) => [input]),
|
||
inspectContent: jest.fn(() => null),
|
||
extractConversationTitleContent: jest.fn(() => []),
|
||
contentFilterBlockResponse: jest.fn(),
|
||
isContentFilterError: jest.fn((error) => error?.code === 'content_filter_block'),
|
||
}),
|
||
);
|
||
jest.mock('@librechat/data-schemas', () => require(MOCKS).dataSchemas());
|
||
jest.mock('librechat-data-provider', () => require(MOCKS).dataProvider());
|
||
jest.mock('~/models', () => require(MOCKS).sharedModels());
|
||
jest.mock('~/server/services/Config', () => require(MOCKS).appConfig());
|
||
jest.mock('~/server/middleware/requireJwtAuth', () => require(MOCKS).requireJwtAuth());
|
||
jest.mock('~/server/middleware', () => require(MOCKS).middlewarePassthrough());
|
||
jest.mock('~/server/utils/import/fork', () => require(MOCKS).forkUtils());
|
||
jest.mock('~/server/utils/import', () => require(MOCKS).importUtils());
|
||
jest.mock('~/cache/getLogStores', () => require(MOCKS).logStores());
|
||
jest.mock('~/server/routes/files/multer', () => require(MOCKS).multerSetup());
|
||
jest.mock('multer', () => require(MOCKS).multerLib());
|
||
jest.mock('~/server/services/Endpoints/azureAssistants', () => require(MOCKS).assistantEndpoint());
|
||
jest.mock('~/server/services/Endpoints/assistants', () => require(MOCKS).assistantEndpoint());
|
||
jest.mock('~/server/services/Endpoints/agents/subagentThreadStore', () =>
|
||
require(MOCKS).subagentThreadStore(),
|
||
);
|
||
jest.mock('~/server/services/Endpoints/agents/backgroundCompletion', () => ({
|
||
pendingBackgroundToolCompletions: { list: jest.fn() },
|
||
}));
|
||
|
||
describe('Convos Routes', () => {
|
||
let app;
|
||
let convosRouter;
|
||
const {
|
||
deleteToolCalls,
|
||
deleteConvos,
|
||
deleteMessages,
|
||
getConvo,
|
||
saveConvo,
|
||
markConvoSeen,
|
||
markConvoUnread,
|
||
} = require('~/models');
|
||
const {
|
||
deleteOwnedAgentCheckpoints,
|
||
deleteAllSharedLinksWithCleanup,
|
||
deleteConvoSharedLinksWithCleanup,
|
||
} = require('@librechat/api');
|
||
const subagentThreadStore = require('~/server/services/Endpoints/agents/subagentThreadStore');
|
||
|
||
beforeAll(() => {
|
||
convosRouter = require('../convos');
|
||
|
||
app = express();
|
||
app.use(express.json());
|
||
|
||
/** Mock authenticated user */
|
||
app.use((req, res, next) => {
|
||
req.user = { id: 'test-user-123', role: 'USER' };
|
||
const tenantId = req.get('x-test-tenant');
|
||
if (tenantId) {
|
||
req.user.tenantId = tenantId;
|
||
}
|
||
req.config = {
|
||
messageFilter: {
|
||
pii: {
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
},
|
||
filters: {
|
||
messages: {
|
||
pii: {
|
||
fields: ['text'],
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
},
|
||
},
|
||
};
|
||
next();
|
||
});
|
||
|
||
app.use('/api/convos', convosRouter);
|
||
});
|
||
|
||
afterAll(() => {
|
||
if (priorLimitMessageIp == null) delete process.env.LIMIT_MESSAGE_IP;
|
||
else process.env.LIMIT_MESSAGE_IP = priorLimitMessageIp;
|
||
if (priorLimitMessageUser == null) delete process.env.LIMIT_MESSAGE_USER;
|
||
else process.env.LIMIT_MESSAGE_USER = priorLimitMessageUser;
|
||
});
|
||
|
||
beforeEach(() => {
|
||
jest.clearAllMocks();
|
||
moderatedTexts.length = 0;
|
||
generationJobManager.getCleanupJob.mockResolvedValue(null);
|
||
generationJobManager.abortJob.mockResolvedValue({ success: true });
|
||
generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue([]);
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([]);
|
||
resetCheckpointRows();
|
||
});
|
||
|
||
it('binds the activity subscription adapter to the subagent task store', () => {
|
||
const binding = subagentActivityHandlerInputs.at(-1);
|
||
const subscriber = { onEvent: jest.fn() };
|
||
|
||
binding.stream.subscribe('child-thread', 'task-1', subscriber);
|
||
|
||
expect(subagentThreadStore.subscribeActivity).toHaveBeenCalledWith(
|
||
'child-thread',
|
||
'task-1',
|
||
subscriber,
|
||
);
|
||
});
|
||
|
||
it('filters and moderates subagent guidance as ordinary user text before control handling', async () => {
|
||
const response = await request(app).post('/api/convos/parent/subagents/child/control').send({
|
||
taskId: 'task-1',
|
||
invocationId: 'invocation-1',
|
||
action: 'queue',
|
||
message: 'Guide the child.',
|
||
});
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(messageIpLimiter).toHaveBeenCalledTimes(1);
|
||
expect(messageUserLimiter).toHaveBeenCalledTimes(1);
|
||
expect(moderateText).toHaveBeenCalledTimes(1);
|
||
expect(moderatedTexts).toEqual(['Guide the child.']);
|
||
|
||
moderateText.mockClear();
|
||
moderatedTexts.length = 0;
|
||
const blocked = await request(app).post('/api/convos/parent/subagents/child/control').send({
|
||
taskId: 'task-1',
|
||
invocationId: 'invocation-2',
|
||
action: 'interrupt',
|
||
message: 'BLOCK-CONTROL',
|
||
});
|
||
|
||
expect(blocked.status).toBe(400);
|
||
expect(blocked.body).toEqual({ error: 'content_filter_block' });
|
||
expect(moderateText).not.toHaveBeenCalled();
|
||
|
||
moderateText.mockClear();
|
||
const oversized = await request(app)
|
||
.post('/api/convos/parent/subagents/child/control')
|
||
.send({
|
||
taskId: 'task-1',
|
||
invocationId: 'invocation-3',
|
||
action: 'queue',
|
||
message: 'x'.repeat(4 * 1024 + 1),
|
||
});
|
||
|
||
expect(oversized.status).toBe(400);
|
||
expect(oversized.body).toEqual({ error: 'Invalid subagent control request' });
|
||
expect(moderateText).not.toHaveBeenCalled();
|
||
|
||
const cancelled = await request(app).post('/api/convos/parent/subagents/child/control').send({
|
||
taskId: 'task-1',
|
||
invocationId: 'invocation-4',
|
||
action: 'cancel',
|
||
});
|
||
|
||
expect(cancelled.status).toBe(200);
|
||
expect(moderateText).not.toHaveBeenCalled();
|
||
|
||
const crafted = await request(app)
|
||
.post('/api/convos/parent/subagents/child/control')
|
||
.send({
|
||
taskId: 'task-1',
|
||
invocationId: 'invocation-5',
|
||
action: 'queue',
|
||
message: 'Use only this bounded guidance.',
|
||
answers: ['This unrelated field must not reach moderation.'],
|
||
});
|
||
|
||
expect(crafted.status).toBe(400);
|
||
expect(crafted.body).toEqual({ error: 'Invalid subagent control request' });
|
||
expect(moderateText).not.toHaveBeenCalled();
|
||
});
|
||
|
||
describe('GET /:conversationId', () => {
|
||
it('returns an ordinary owned conversation', async () => {
|
||
getConvo.mockResolvedValue({ conversationId: 'ordinary', title: 'Ordinary' });
|
||
|
||
const response = await request(app).get('/api/convos/ordinary');
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(response.body).toEqual({ conversationId: 'ordinary', title: 'Ordinary' });
|
||
expect(getConvo).toHaveBeenCalledWith('test-user-123', 'ordinary');
|
||
});
|
||
|
||
it('returns the same not-found response for an owned child thread', async () => {
|
||
getConvo.mockResolvedValue({
|
||
conversationId: 'child',
|
||
subagentThread: { parentConversationId: 'parent' },
|
||
});
|
||
|
||
const childResponse = await request(app).get('/api/convos/child');
|
||
getConvo.mockResolvedValue(null);
|
||
const missingResponse = await request(app).get('/api/convos/missing');
|
||
|
||
expect(childResponse.status).toBe(404);
|
||
expect(childResponse.text).toBe('');
|
||
expect(childResponse.status).toBe(missingResponse.status);
|
||
expect(childResponse.text).toBe(missingResponse.text);
|
||
expect(getConvo).toHaveBeenNthCalledWith(1, 'test-user-123', 'child');
|
||
});
|
||
});
|
||
|
||
describe('GET /:conversationId/pull-request', () => {
|
||
it('is registered and reaches the pull request handler', async () => {
|
||
const response = await request(app).get('/api/convos/ordinary/pull-request');
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(response.body).toEqual({ pullRequest: null });
|
||
});
|
||
|
||
it('does not fall through to the conversation read', async () => {
|
||
await request(app).get('/api/convos/ordinary/pull-request');
|
||
|
||
expect(getConvo).not.toHaveBeenCalled();
|
||
});
|
||
});
|
||
|
||
describe('POST /import', () => {
|
||
const { importConversations } = require('~/server/utils/import');
|
||
|
||
it('passes source-aware filters into conversation import', async () => {
|
||
importConversations.mockResolvedValue();
|
||
|
||
const response = await request(app).post('/api/convos/import');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(importConversations).toHaveBeenCalledWith({
|
||
filepath: '/tmp/test-file.json',
|
||
requestUserId: 'test-user-123',
|
||
userRole: 'USER',
|
||
interfaceConfig: undefined,
|
||
filters: {
|
||
messages: {
|
||
pii: {
|
||
fields: ['text'],
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
},
|
||
},
|
||
legacyPii: {
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
});
|
||
});
|
||
|
||
it('returns only metadata-safe filter details for a blocked import', async () => {
|
||
const error = Object.assign(new Error('blocked'), {
|
||
code: 'content_filter_block',
|
||
statusCode: 400,
|
||
body: {
|
||
error: 'content_filter_block',
|
||
message: 'Submitted content contains a restricted value. Remove it and try again.',
|
||
source: 'message',
|
||
field: 'text',
|
||
},
|
||
});
|
||
importConversations.mockRejectedValue(error);
|
||
|
||
const response = await request(app).post('/api/convos/import');
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual(error.body);
|
||
expect(response.body).not.toHaveProperty('detectorId');
|
||
expect(response.body).not.toHaveProperty('ruleId');
|
||
expect(response.body).not.toHaveProperty('fragmentPath');
|
||
const { logger } = require('@librechat/data-schemas');
|
||
expect(logger.error).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('returns an actionable client error for an oversized imported record', async () => {
|
||
const message = 'Each imported conversation or message must be at most 16711680 bytes';
|
||
const error = Object.assign(new Error(message), {
|
||
name: 'ConversationImportError',
|
||
code: 'invalid_request',
|
||
statusCode: 413,
|
||
body: { error: 'invalid_request', message },
|
||
});
|
||
importConversations.mockRejectedValue(error);
|
||
|
||
const response = await request(app).post('/api/convos/import');
|
||
|
||
expect(response.status).toBe(413);
|
||
expect(response.body).toEqual(error.body);
|
||
const { logger } = require('@librechat/data-schemas');
|
||
expect(logger.error).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('preserves the generic server error contract for other import failures', async () => {
|
||
const error = new Error('invalid JSON');
|
||
importConversations.mockRejectedValue(error);
|
||
|
||
const response = await request(app).post('/api/convos/import');
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.text).toBe('Error processing file');
|
||
const { logger } = require('@librechat/data-schemas');
|
||
expect(logger.error).toHaveBeenCalledWith('Error processing file', error);
|
||
});
|
||
});
|
||
|
||
describe('POST /fork', () => {
|
||
const { forkConversation } = require('~/server/utils/import/fork');
|
||
|
||
it('passes source-aware filters into the fork preflight', async () => {
|
||
forkConversation.mockResolvedValue({ conversation: { conversationId: 'forked-convo' } });
|
||
|
||
const response = await request(app).post('/api/convos/fork').send({
|
||
conversationId: 'source-convo',
|
||
messageId: 'source-message',
|
||
});
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(forkConversation).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
requestUserId: 'test-user-123',
|
||
originalConvoId: 'source-convo',
|
||
targetMessageId: 'source-message',
|
||
filters: {
|
||
messages: {
|
||
pii: {
|
||
fields: ['text'],
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
},
|
||
},
|
||
legacyPii: {
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
}),
|
||
);
|
||
});
|
||
|
||
it('forwards excludeFiles only when it is exactly true', async () => {
|
||
forkConversation.mockResolvedValue({ conversation: { conversationId: 'forked-convo' } });
|
||
|
||
await request(app).post('/api/convos/fork').send({
|
||
conversationId: 'source-convo',
|
||
messageId: 'source-message',
|
||
excludeFiles: true,
|
||
});
|
||
await request(app).post('/api/convos/fork').send({
|
||
conversationId: 'source-convo',
|
||
messageId: 'source-message',
|
||
excludeFiles: 'true',
|
||
});
|
||
|
||
expect(forkConversation).toHaveBeenNthCalledWith(
|
||
1,
|
||
expect.objectContaining({ excludeFiles: true }),
|
||
);
|
||
expect(forkConversation).toHaveBeenNthCalledWith(
|
||
2,
|
||
expect.objectContaining({ excludeFiles: false }),
|
||
);
|
||
});
|
||
|
||
it('returns a raw-free 400 when cloned content is blocked', async () => {
|
||
const error = Object.assign(new Error('PRIVATE-SENTINEL'), {
|
||
code: 'content_filter_block',
|
||
statusCode: 400,
|
||
body: {
|
||
error: 'content_filter_block',
|
||
message: 'Submitted content contains a restricted value. Remove it and try again.',
|
||
source: 'message',
|
||
field: 'text',
|
||
},
|
||
});
|
||
forkConversation.mockRejectedValue(error);
|
||
|
||
const response = await request(app).post('/api/convos/fork').send({
|
||
conversationId: 'source-convo',
|
||
messageId: 'source-message',
|
||
});
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual(error.body);
|
||
expect(JSON.stringify(response.body)).not.toContain('PRIVATE-SENTINEL');
|
||
});
|
||
|
||
it('returns an actionable client error when a cloned record is oversized', async () => {
|
||
const message = 'Each imported conversation or message must be at most 16711680 bytes';
|
||
const error = Object.assign(new Error(message), {
|
||
name: 'ConversationImportError',
|
||
code: 'invalid_request',
|
||
statusCode: 413,
|
||
body: { error: 'invalid_request', message },
|
||
});
|
||
forkConversation.mockRejectedValue(error);
|
||
|
||
const response = await request(app).post('/api/convos/fork').send({
|
||
conversationId: 'source-convo',
|
||
messageId: 'source-message',
|
||
});
|
||
|
||
expect(response.status).toBe(413);
|
||
expect(response.body).toEqual(error.body);
|
||
const { logger } = require('@librechat/data-schemas');
|
||
expect(logger.error).not.toHaveBeenCalled();
|
||
});
|
||
});
|
||
|
||
describe('POST /duplicate', () => {
|
||
const { duplicateConversation } = require('~/server/utils/import/fork');
|
||
|
||
it('passes source-aware filters into the duplicate preflight', async () => {
|
||
duplicateConversation.mockResolvedValue({
|
||
conversation: { conversationId: 'duplicated-convo' },
|
||
});
|
||
|
||
const response = await request(app)
|
||
.post('/api/convos/duplicate')
|
||
.send({ conversationId: 'source-convo' });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(duplicateConversation).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
userId: 'test-user-123',
|
||
conversationId: 'source-convo',
|
||
filters: {
|
||
messages: {
|
||
pii: {
|
||
fields: ['text'],
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
},
|
||
},
|
||
legacyPii: {
|
||
starterPatterns: ['sk_prefix'],
|
||
},
|
||
}),
|
||
);
|
||
});
|
||
|
||
it('returns a raw-free 400 when cloned content is blocked', async () => {
|
||
const error = Object.assign(new Error('PRIVATE-SENTINEL'), {
|
||
code: 'content_filter_block',
|
||
statusCode: 400,
|
||
body: {
|
||
error: 'content_filter_block',
|
||
message: 'Submitted content contains a restricted value. Remove it and try again.',
|
||
source: 'message',
|
||
field: 'text',
|
||
},
|
||
});
|
||
duplicateConversation.mockRejectedValue(error);
|
||
|
||
const response = await request(app)
|
||
.post('/api/convos/duplicate')
|
||
.send({ conversationId: 'source-convo' });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual(error.body);
|
||
expect(JSON.stringify(response.body)).not.toContain('PRIVATE-SENTINEL');
|
||
});
|
||
|
||
it('returns an actionable client error when a cloned record is oversized', async () => {
|
||
const message = 'Each imported conversation or message must be at most 16711680 bytes';
|
||
const error = Object.assign(new Error(message), {
|
||
name: 'ConversationImportError',
|
||
code: 'invalid_request',
|
||
statusCode: 413,
|
||
body: { error: 'invalid_request', message },
|
||
});
|
||
duplicateConversation.mockRejectedValue(error);
|
||
|
||
const response = await request(app)
|
||
.post('/api/convos/duplicate')
|
||
.send({ conversationId: 'source-convo' });
|
||
|
||
expect(response.status).toBe(413);
|
||
expect(response.body).toEqual(error.body);
|
||
const { logger } = require('@librechat/data-schemas');
|
||
expect(logger.error).not.toHaveBeenCalled();
|
||
});
|
||
});
|
||
|
||
describe('DELETE /all', () => {
|
||
it('prunes the deleted conversations’ owned generation checkpoint scopes', async () => {
|
||
// Generation-scoped checkpoints are removed eagerly after their ownership is proven.
|
||
const conversationIds = ['conv-a', 'conv-b'];
|
||
deleteConvos.mockImplementation(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(conversationIds);
|
||
return { deletedCount: 2, conversationIds };
|
||
});
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 0 });
|
||
deleteAllSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 0 });
|
||
generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => ({
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId,
|
||
checkpointNamespace: checkpointNamespace(conversationId === 'conv-a' ? 1 : 2),
|
||
generationProtocolVersion: 2,
|
||
},
|
||
status: 'complete',
|
||
createdAt: Date.now(),
|
||
}));
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
undefined,
|
||
undefined,
|
||
);
|
||
/** The deletion runs inside the owner admission fence, not around it. */
|
||
expect(subagentThreadStore.withOwnerDeletionFence).toHaveBeenCalledTimes(1);
|
||
const [fencedUserId, fencedTenantId] =
|
||
subagentThreadStore.withOwnerDeletionFence.mock.calls[0];
|
||
expect(fencedUserId).toBe('test-user-123');
|
||
expect(fencedTenantId).toBeUndefined();
|
||
expect(subagentThreadStore.cancelAndDrainForOwner).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('drains a paused event actor after owner-wide deletion removes its conversation', async () => {
|
||
const createdAt = Date.now();
|
||
generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue([
|
||
'paused-event-child',
|
||
]);
|
||
deleteConvos.mockResolvedValue({
|
||
deletedCount: 1,
|
||
conversationIds: ['paused-event-child'],
|
||
});
|
||
generationJobManager.getCleanupJob.mockImplementation(async (conversationId) =>
|
||
conversationId === 'paused-event-child'
|
||
? {
|
||
metadata: { userId: 'test-user-123' },
|
||
status: 'requires_action',
|
||
createdAt,
|
||
}
|
||
: null,
|
||
);
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('paused-event-child', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
});
|
||
|
||
it('drains every owner remote run before selecting the delete-all snapshot', async () => {
|
||
const createdAt = Date.now();
|
||
generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue([
|
||
'resp-new-conversation',
|
||
]);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) =>
|
||
streamId === 'resp-new-conversation'
|
||
? {
|
||
conversationId: 'conversation-not-yet-persisted',
|
||
metadata: { userId: 'test-user-123' },
|
||
status: 'running',
|
||
createdAt,
|
||
}
|
||
: null,
|
||
);
|
||
deleteConvos.mockResolvedValue({
|
||
deletedCount: 1,
|
||
conversationIds: ['conversation-not-yet-persisted'],
|
||
});
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.getCleanupBlockingJobIdsForUser).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp-new-conversation', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
expect(generationJobManager.abortJob.mock.invocationCallOrder[0]).toBeLessThan(
|
||
deleteConvos.mock.invocationCallOrder[0],
|
||
);
|
||
});
|
||
|
||
it('re-drains and removes persistence created during a recovered owner-fence gap', async () => {
|
||
const createdAt = Date.now();
|
||
generationJobManager.getCleanupBlockingJobIdsForUser
|
||
.mockResolvedValueOnce([])
|
||
.mockResolvedValueOnce(['resp-gap']);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) =>
|
||
streamId === 'resp-gap'
|
||
? {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId: 'gap-conversation',
|
||
checkpointNamespace: checkpointNamespace(3),
|
||
generationProtocolVersion: 2,
|
||
},
|
||
status: 'running',
|
||
createdAt,
|
||
}
|
||
: null,
|
||
);
|
||
deleteConvos
|
||
.mockResolvedValueOnce({ deletedCount: 1, conversationIds: ['original'] })
|
||
.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
expect(options).toEqual(
|
||
expect.objectContaining({ allowEmpty: true, beforeDelete: expect.any(Function) }),
|
||
);
|
||
await options.beforeDelete?.(['gap-conversation']);
|
||
return { deletedCount: 1, conversationIds: ['gap-conversation'] };
|
||
});
|
||
subagentThreadStore.withOwnerDeletionFence.mockImplementationOnce(
|
||
async (_userId, _tenantId, deletion, recover) => {
|
||
const result = await deletion();
|
||
await recover();
|
||
return result;
|
||
},
|
||
);
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp-gap', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
expect(
|
||
deleteConvos.mock.calls.filter(([, filter]) => Object.keys(filter).length === 0),
|
||
).toHaveLength(2);
|
||
expect(deleteMessages).toHaveBeenCalledWith({ user: 'test-user-123' });
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
undefined,
|
||
undefined,
|
||
);
|
||
});
|
||
|
||
it('retries owner message cleanup after conversations were already removed', async () => {
|
||
deleteConvos
|
||
.mockResolvedValueOnce({ deletedCount: 1, conversationIds: ['original'] })
|
||
.mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] });
|
||
deleteMessages
|
||
.mockRejectedValueOnce(new Error('message database unavailable'))
|
||
.mockResolvedValueOnce({ deletedCount: 1 });
|
||
|
||
const first = await request(app).delete('/api/convos/all');
|
||
const retry = await request(app).delete('/api/convos/all');
|
||
|
||
expect(first.status).toBe(500);
|
||
expect(retry.status).toBe(201);
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
undefined,
|
||
undefined,
|
||
);
|
||
expect(deleteConvos).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
{},
|
||
expect.objectContaining({ allowEmpty: true }),
|
||
);
|
||
expect(deleteMessages).toHaveBeenLastCalledWith({ user: 'test-user-123' });
|
||
});
|
||
|
||
it('should delete all conversations, tool calls, and shared links for a user', async () => {
|
||
const mockDbResponse = {
|
||
deletedCount: 5,
|
||
message: 'All conversations deleted successfully',
|
||
};
|
||
|
||
deleteConvos.mockResolvedValue(mockDbResponse);
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 10 });
|
||
deleteAllSharedLinksWithCleanup.mockResolvedValue({
|
||
message: 'All shared links deleted successfully',
|
||
deletedCount: 3,
|
||
});
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(response.body).toMatchObject(mockDbResponse);
|
||
|
||
/** Verify deleteConvos was called with correct userId */
|
||
expect(deleteConvos).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
{},
|
||
expect.objectContaining({ beforeDelete: expect.any(Function) }),
|
||
);
|
||
expect(deleteConvos).toHaveBeenCalledTimes(1);
|
||
|
||
/** Verify deleteToolCalls was called with correct userId */
|
||
expect(deleteToolCalls).toHaveBeenCalledWith('test-user-123');
|
||
expect(deleteToolCalls).toHaveBeenCalledTimes(1);
|
||
|
||
/** Verify deleteAllSharedLinksWithCleanup was called with correct userId */
|
||
expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123');
|
||
expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledTimes(1);
|
||
});
|
||
|
||
it('should call deleteAllSharedLinksWithCleanup even when no conversations exist', async () => {
|
||
const mockDbResponse = {
|
||
deletedCount: 0,
|
||
message: 'No conversations to delete',
|
||
};
|
||
|
||
deleteConvos.mockResolvedValue(mockDbResponse);
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 0 });
|
||
deleteAllSharedLinksWithCleanup.mockResolvedValue({
|
||
message: 'All shared links deleted successfully',
|
||
deletedCount: 0,
|
||
});
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123');
|
||
});
|
||
|
||
it('should return 500 if deleteConvos fails', async () => {
|
||
const errorMessage = 'Database connection error';
|
||
deleteConvos.mockRejectedValue(new Error(errorMessage));
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.text).toBe('Error clearing conversations');
|
||
|
||
/** Verify error was logged */
|
||
const { logger } = require('@librechat/data-schemas');
|
||
expect(logger.error).toHaveBeenCalledWith('Error clearing conversations', expect.any(Error));
|
||
});
|
||
|
||
it('does not delete conversations when cross-replica task draining fails', async () => {
|
||
/** Draining happens inside the admission fence, so its failure fails the fence. */
|
||
subagentThreadStore.withOwnerDeletionFence.mockRejectedValueOnce(
|
||
new Error('task owner unavailable'),
|
||
);
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(deleteConvos).not.toHaveBeenCalled();
|
||
expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled();
|
||
expect(deleteToolCalls).not.toHaveBeenCalled();
|
||
expect(deleteAllSharedLinksWithCleanup).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 500 if deleteToolCalls fails', async () => {
|
||
deleteConvos.mockResolvedValue({ deletedCount: 5 });
|
||
deleteToolCalls.mockRejectedValue(new Error('Tool calls deletion failed'));
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.text).toBe('Error clearing conversations');
|
||
});
|
||
|
||
it('should return 500 if deleteAllSharedLinksWithCleanup fails', async () => {
|
||
deleteConvos.mockResolvedValue({ deletedCount: 5 });
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 10 });
|
||
deleteAllSharedLinksWithCleanup.mockRejectedValue(new Error('Shared links deletion failed'));
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.text).toBe('Error clearing conversations');
|
||
});
|
||
|
||
it('should handle multiple users independently', async () => {
|
||
/** First user */
|
||
deleteConvos.mockResolvedValue({ deletedCount: 3 });
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 5 });
|
||
deleteAllSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 2 });
|
||
|
||
let response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123');
|
||
|
||
jest.clearAllMocks();
|
||
|
||
/** Second user (simulate different user by modifying middleware) */
|
||
const app2 = express();
|
||
app2.use(express.json());
|
||
app2.use((req, res, next) => {
|
||
req.user = { id: 'test-user-456' };
|
||
next();
|
||
});
|
||
app2.use('/api/convos', require('../convos'));
|
||
|
||
deleteConvos.mockResolvedValue({ deletedCount: 7 });
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 12 });
|
||
deleteAllSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 4 });
|
||
|
||
response = await request(app2).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-456');
|
||
});
|
||
|
||
it('should execute deletions in correct sequence', async () => {
|
||
const executionOrder = [];
|
||
|
||
deleteConvos.mockImplementation(() => {
|
||
executionOrder.push('deleteConvos');
|
||
return Promise.resolve({ deletedCount: 5 });
|
||
});
|
||
|
||
deleteToolCalls.mockImplementation(() => {
|
||
executionOrder.push('deleteToolCalls');
|
||
return Promise.resolve({ deletedCount: 10 });
|
||
});
|
||
|
||
deleteAllSharedLinksWithCleanup.mockImplementation(() => {
|
||
executionOrder.push('deleteAllSharedLinksWithCleanup');
|
||
return Promise.resolve({ deletedCount: 3 });
|
||
});
|
||
|
||
await request(app).delete('/api/convos/all');
|
||
|
||
/** Verify all three functions were called */
|
||
expect(executionOrder).toEqual([
|
||
'deleteConvos',
|
||
'deleteToolCalls',
|
||
'deleteAllSharedLinksWithCleanup',
|
||
]);
|
||
});
|
||
|
||
it('should maintain data integrity by cleaning up shared links when conversations are deleted', async () => {
|
||
/** This test ensures that orphaned shared links are prevented */
|
||
const mockConvosDeleted = { deletedCount: 10 };
|
||
const mockToolCallsDeleted = { deletedCount: 15 };
|
||
const mockSharedLinksDeleted = {
|
||
message: 'All shared links deleted successfully',
|
||
deletedCount: 8,
|
||
};
|
||
|
||
deleteConvos.mockResolvedValue(mockConvosDeleted);
|
||
deleteToolCalls.mockResolvedValue(mockToolCallsDeleted);
|
||
deleteAllSharedLinksWithCleanup.mockResolvedValue(mockSharedLinksDeleted);
|
||
|
||
const response = await request(app).delete('/api/convos/all');
|
||
|
||
expect(response.status).toBe(201);
|
||
|
||
/** Verify that shared links cleanup was called for the same user */
|
||
expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123');
|
||
|
||
/** Verify no shared links remain for deleted conversations */
|
||
expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledAfter(deleteConvos);
|
||
});
|
||
});
|
||
|
||
describe('DELETE /', () => {
|
||
it('fences the owner when DELETE / is called without a conversation filter', async () => {
|
||
deleteConvos.mockResolvedValue({ deletedCount: 3, conversationIds: ['a', 'b', 'c'] });
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { thread_id: 'thread-abc' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
/** An empty filter deletes everything, so it takes the same admission fence. */
|
||
expect(subagentThreadStore.withOwnerDeletionFence).toHaveBeenCalledTimes(1);
|
||
expect(subagentThreadStore.withOwnerDeletionFence.mock.calls[0][0]).toBe('test-user-123');
|
||
expect(subagentThreadStore.cancelAndDrainForOwner).not.toHaveBeenCalled();
|
||
expect(deleteConvos).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
{},
|
||
expect.objectContaining({ beforeDelete: expect.any(Function) }),
|
||
);
|
||
expect(subagentThreadStore.withOwnerDeletionFence.mock.calls[0][3]).toEqual(
|
||
expect.any(Function),
|
||
);
|
||
});
|
||
|
||
it('drains owner remote runs before the empty-filter deletion snapshot', async () => {
|
||
const createdAt = Date.now();
|
||
generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue(['resp-new']);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) =>
|
||
streamId === 'resp-new'
|
||
? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt }
|
||
: null,
|
||
);
|
||
deleteConvos.mockResolvedValue({
|
||
deletedCount: 1,
|
||
conversationIds: ['new-conversation'],
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { thread_id: 'thread-abc' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp-new', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
expect(generationJobManager.abortJob.mock.invocationCallOrder[0]).toBeLessThan(
|
||
deleteConvos.mock.invocationCallOrder[0],
|
||
);
|
||
});
|
||
|
||
it('drains a paused event actor after an empty-filter deletion removes it', async () => {
|
||
const createdAt = Date.now();
|
||
deleteConvos.mockResolvedValue({
|
||
deletedCount: 1,
|
||
conversationIds: ['paused-event-child'],
|
||
});
|
||
generationJobManager.getCleanupJob.mockImplementation(async (conversationId) =>
|
||
conversationId === 'paused-event-child'
|
||
? {
|
||
metadata: { userId: 'test-user-123' },
|
||
status: 'requires_action',
|
||
createdAt,
|
||
}
|
||
: null,
|
||
);
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { thread_id: 'thread-abc' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('paused-event-child', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
});
|
||
|
||
it('fails closed before checkpoint pruning when generation lookup stays unavailable', async () => {
|
||
deleteConvos.mockImplementation(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['paused-event-child']);
|
||
return {
|
||
deletedCount: 1,
|
||
conversationIds: ['paused-event-child'],
|
||
};
|
||
});
|
||
generationJobManager.getCleanupJob.mockRejectedValue(
|
||
new Error('generation store unavailable'),
|
||
);
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { thread_id: 'thread-abc' } });
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(generationJobManager.getCleanupJob).toHaveBeenCalledTimes(3);
|
||
expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('cancels root and descendant leases and cleans every cascaded conversation', async () => {
|
||
deleteConvos.mockResolvedValue({
|
||
deletedCount: 2,
|
||
conversationIds: ['parent-conversation', 'child-conversation'],
|
||
});
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 1 });
|
||
deleteConvoSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 1 });
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({
|
||
arg: { conversationId: 'parent-conversation' },
|
||
});
|
||
|
||
expect(response.status).toBe(201);
|
||
/** The plan is resolved before deletion, while those rows can still be read. */
|
||
expect(subagentThreadStore.planCancellationForConversations).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
['parent-conversation'],
|
||
undefined,
|
||
);
|
||
expect(
|
||
subagentThreadStore.planCancellationForConversations.mock.invocationCallOrder[0],
|
||
).toBeLessThan(deleteConvos.mock.invocationCallOrder[0]);
|
||
/** It is applied once before deletion and replayed after with the cascade. */
|
||
expect(subagentThreadStore.cancelPlan).toHaveBeenCalledTimes(2);
|
||
expect(subagentThreadStore.cancelPlan.mock.calls[0][1]).toBeUndefined();
|
||
expect(subagentThreadStore.cancelPlan.mock.calls[1][1]).toEqual([
|
||
'parent-conversation',
|
||
'child-conversation',
|
||
]);
|
||
expect(deleteToolCalls.mock.calls.map((call) => call[1])).toEqual([
|
||
'parent-conversation',
|
||
'child-conversation',
|
||
]);
|
||
expect(deleteConvoSharedLinksWithCleanup.mock.calls.map((call) => call[1])).toEqual([
|
||
'parent-conversation',
|
||
'child-conversation',
|
||
]);
|
||
});
|
||
|
||
it('drains an active child generation and removes persistence that races deletion', async () => {
|
||
const createdAt = Date.now();
|
||
deleteConvos.mockResolvedValue({
|
||
deletedCount: 2,
|
||
conversationIds: ['parent-conversation', 'child-conversation'],
|
||
});
|
||
generationJobManager.getCleanupJob.mockImplementation(async (conversationId) =>
|
||
conversationId === 'child-conversation'
|
||
? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt }
|
||
: null,
|
||
);
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'parent-conversation' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('child-conversation', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
expect(deleteConvos).toHaveBeenNthCalledWith(
|
||
2,
|
||
'test-user-123',
|
||
{ conversationId: { $in: ['parent-conversation', 'child-conversation'] } },
|
||
expect.objectContaining({ allowEmpty: true }),
|
||
);
|
||
expect(deleteMessages).toHaveBeenCalledWith({
|
||
user: 'test-user-123',
|
||
conversationId: { $in: ['parent-conversation', 'child-conversation'] },
|
||
});
|
||
});
|
||
|
||
it('drains response-id runs indexed under a deleted conversation', async () => {
|
||
const createdAt = Date.now();
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([
|
||
'resp_remote-run',
|
||
]);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) =>
|
||
streamId === 'resp_remote-run'
|
||
? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt }
|
||
: null,
|
||
);
|
||
deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.getCleanupBlockingJobIdsForConversations).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
['conversation-1'],
|
||
undefined,
|
||
);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp_remote-run', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
});
|
||
|
||
it('preserves foreign and legacy checkpoints when conversation IDs collide', async () => {
|
||
const conversationIds = ['conversation-1', 'child-conversation'];
|
||
const jobs = {
|
||
'resp-owned': {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId: 'conversation-1',
|
||
checkpointNamespace: checkpointNamespace(4),
|
||
generationProtocolVersion: 2,
|
||
},
|
||
},
|
||
'task-owned-child': {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId: 'child-conversation',
|
||
checkpointNamespace: checkpointNamespace(5),
|
||
generationProtocolVersion: 2,
|
||
},
|
||
},
|
||
'resp-foreign-user': {
|
||
metadata: {
|
||
userId: 'foreign-user',
|
||
conversationId: 'conversation-1',
|
||
checkpointNamespace: 'foreign-user-generation',
|
||
generationProtocolVersion: 2,
|
||
},
|
||
},
|
||
'resp-foreign-tenant': {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
tenantId: 'foreign-tenant',
|
||
conversationId: 'conversation-1',
|
||
checkpointNamespace: 'foreign-tenant-generation',
|
||
generationProtocolVersion: 2,
|
||
},
|
||
},
|
||
'resp-legacy': {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId: 'conversation-1',
|
||
checkpointNamespace: '',
|
||
generationProtocolVersion: 1,
|
||
},
|
||
},
|
||
};
|
||
resetCheckpointRows([
|
||
{ threadId: 'conversation-1', checkpointNamespace: checkpointNamespace(4) },
|
||
{
|
||
threadId: 'conversation-1',
|
||
checkpointNamespace: `${checkpointNamespace(4)}|subgraph`,
|
||
},
|
||
{ threadId: 'child-conversation', checkpointNamespace: checkpointNamespace(5) },
|
||
{ threadId: 'conversation-1', checkpointNamespace: 'foreign-user-generation' },
|
||
{ threadId: 'conversation-1', checkpointNamespace: 'foreign-tenant-generation' },
|
||
{ threadId: 'conversation-1', checkpointNamespace: '' },
|
||
]);
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue(
|
||
Object.keys(jobs),
|
||
);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) => {
|
||
const job = jobs[streamId];
|
||
return job == null ? null : { ...job, status: 'complete', createdAt: Date.now() };
|
||
});
|
||
deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(conversationIds);
|
||
return { deletedCount: 2, conversationIds };
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(checkpointRows).toEqual([
|
||
{ threadId: 'conversation-1', checkpointNamespace: 'foreign-user-generation' },
|
||
{ threadId: 'conversation-1', checkpointNamespace: 'foreign-tenant-generation' },
|
||
{ threadId: 'conversation-1', checkpointNamespace: '' },
|
||
]);
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
['conversation-1', 'child-conversation'],
|
||
undefined,
|
||
);
|
||
});
|
||
|
||
it('deletes an owned checkpoint after its terminal job hash expires', async () => {
|
||
const scope = {
|
||
threadId: 'conversation-1',
|
||
checkpointNamespace: checkpointNamespace(8),
|
||
};
|
||
resetCheckpointRows([scope]);
|
||
deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(checkpointRows).toEqual([]);
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
['conversation-1'],
|
||
undefined,
|
||
);
|
||
});
|
||
|
||
it('retains checkpoint payload when conversation deletion fails after its snapshot', async () => {
|
||
const scope = { threadId: 'conversation-1', checkpointNamespace: checkpointNamespace(8) };
|
||
resetCheckpointRows([scope]);
|
||
deleteConvos.mockImplementationOnce(async (_owner, _filter, options) => {
|
||
await options.beforeDelete(['conversation-1']);
|
||
throw new Error('conversation deletion failed');
|
||
});
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
expect(response.status).toBe(500);
|
||
expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled();
|
||
expect(checkpointRows).toEqual([scope]);
|
||
});
|
||
|
||
it('fails closed when saver deletion fails', async () => {
|
||
deleteOwnedAgentCheckpoints.mockRejectedValueOnce(new Error('checkpoint store unavailable'));
|
||
deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(500);
|
||
});
|
||
|
||
it('retries checkpoint cleanup for descendants after all conversation records are gone', async () => {
|
||
deleteOwnedAgentCheckpoints.mockRejectedValueOnce(new Error('post-delete cleanup failed'));
|
||
deleteConvos
|
||
.mockImplementationOnce(async (_owner, _filter, options) => {
|
||
await options.beforeDelete(['conversation-1', 'child-conversation']);
|
||
return { deletedCount: 2, conversationIds: ['conversation-1', 'child-conversation'] };
|
||
})
|
||
.mockResolvedValue({ deletedCount: 0, conversationIds: [] });
|
||
const first = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
expect(first.status).toBe(500);
|
||
checkpointRows.push({
|
||
threadId: 'child-conversation',
|
||
checkpointNamespace: checkpointNamespace(13),
|
||
});
|
||
// Restore only a late checkpoint; the deletion intent must remain from the first request.
|
||
const second = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
expect(second.status).toBe(201);
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenLastCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
['conversation-1', 'child-conversation'],
|
||
undefined,
|
||
);
|
||
expect(checkpointRows).toEqual([]);
|
||
});
|
||
|
||
it('cleans checkpoints from every cascade wave', async () => {
|
||
const jobs = {
|
||
'run-parent': {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId: 'parent-conversation',
|
||
checkpointNamespace: checkpointNamespace(11),
|
||
generationProtocolVersion: 2,
|
||
},
|
||
},
|
||
'run-child': {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId: 'child-conversation',
|
||
checkpointNamespace: checkpointNamespace(12),
|
||
generationProtocolVersion: 2,
|
||
},
|
||
},
|
||
};
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockImplementation(
|
||
async (_userId, conversationIds) =>
|
||
conversationIds.map((conversationId) =>
|
||
conversationId === 'parent-conversation' ? 'run-parent' : 'run-child',
|
||
),
|
||
);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) => {
|
||
const job = jobs[streamId];
|
||
return job == null ? null : { ...job, status: 'complete', createdAt: Date.now() };
|
||
});
|
||
deleteConvos
|
||
.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['parent-conversation']);
|
||
await options.beforeDelete?.(['child-conversation']);
|
||
return {
|
||
deletedCount: 2,
|
||
conversationIds: ['parent-conversation', 'child-conversation'],
|
||
};
|
||
})
|
||
.mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] });
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'parent-conversation' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
undefined,
|
||
['parent-conversation', 'child-conversation'],
|
||
undefined,
|
||
);
|
||
});
|
||
|
||
it('drains a tenant user legacy generation without pruning its ambiguous namespace', async () => {
|
||
const createdAt = Date.now();
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([
|
||
'legacy-run',
|
||
]);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) =>
|
||
streamId === 'legacy-run'
|
||
? {
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
conversationId: 'conversation-1',
|
||
checkpointNamespace: 'legacy-tenant-generation',
|
||
generationProtocolVersion: 2,
|
||
},
|
||
status: 'running',
|
||
createdAt,
|
||
}
|
||
: null,
|
||
);
|
||
deleteConvos
|
||
.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
})
|
||
.mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] });
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.set('x-test-tenant', 'tenant-1')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('legacy-run', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
'tenant-1',
|
||
['conversation-1'],
|
||
undefined,
|
||
);
|
||
});
|
||
|
||
it('waits for terminal response-id runs whose provider writes are undrained', async () => {
|
||
const createdAt = Date.now();
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([
|
||
'resp_terminal-run',
|
||
]);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) =>
|
||
streamId === 'resp_terminal-run'
|
||
? {
|
||
metadata: { userId: 'test-user-123', providerDrained: false },
|
||
status: 'complete',
|
||
createdAt,
|
||
}
|
||
: null,
|
||
);
|
||
deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp_terminal-run', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
});
|
||
|
||
it('catches a response-id run admitted after the pre-delete snapshot', async () => {
|
||
const createdAt = Date.now();
|
||
let deletionCommitted = false;
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockImplementation(async () =>
|
||
deletionCommitted ? ['resp_late-run'] : [],
|
||
);
|
||
generationJobManager.getCleanupJob.mockImplementation(async (streamId) =>
|
||
streamId === 'resp_late-run'
|
||
? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt }
|
||
: null,
|
||
);
|
||
deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
deletionCommitted = true;
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.getCleanupBlockingJobIdsForConversations).toHaveBeenCalledTimes(
|
||
2,
|
||
);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp_late-run', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
});
|
||
|
||
it('removes persistence even when a racing response drains before post-delete discovery', async () => {
|
||
deleteConvos
|
||
.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
})
|
||
.mockResolvedValueOnce({ deletedCount: 1, conversationIds: ['conversation-1'] });
|
||
generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([]);
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).not.toHaveBeenCalled();
|
||
expect(deleteConvos).toHaveBeenNthCalledWith(
|
||
2,
|
||
'test-user-123',
|
||
{ conversationId: { $in: ['conversation-1'] } },
|
||
expect.objectContaining({ allowEmpty: true }),
|
||
);
|
||
expect(deleteMessages).toHaveBeenCalledWith({
|
||
user: 'test-user-123',
|
||
conversationId: { $in: ['conversation-1'] },
|
||
});
|
||
});
|
||
|
||
it('fails closed when the idempotent remnant sweep hits a storage failure', async () => {
|
||
deleteConvos
|
||
.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
})
|
||
.mockRejectedValueOnce(new Error('remnant database unavailable'));
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.text).toBe('Error clearing conversations');
|
||
expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('fails closed when remnant message cleanup is unavailable', async () => {
|
||
deleteConvos
|
||
.mockImplementationOnce(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['conversation-1']);
|
||
return { deletedCount: 1, conversationIds: ['conversation-1'] };
|
||
})
|
||
.mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] });
|
||
deleteMessages.mockRejectedValueOnce(new Error('message database unavailable'));
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'conversation-1' } });
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.text).toBe('Error clearing conversations');
|
||
expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('does not prune generation persistence when provider stop is unconfirmed', async () => {
|
||
const createdAt = Date.now();
|
||
let deletionCommitted = false;
|
||
deleteConvos.mockImplementation(async (_userId, _filter, options) => {
|
||
await options.beforeDelete?.(['child-conversation']);
|
||
deletionCommitted = true;
|
||
return {
|
||
deletedCount: 2,
|
||
conversationIds: ['parent-conversation', 'child-conversation'],
|
||
};
|
||
});
|
||
generationJobManager.getCleanupJob.mockImplementation(async (conversationId) =>
|
||
conversationId === 'child-conversation'
|
||
? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt }
|
||
: null,
|
||
);
|
||
generationJobManager.abortJob.mockResolvedValue({
|
||
success: false,
|
||
failureReason: 'job_still_active',
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'parent-conversation' } });
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(deleteConvos).toHaveBeenCalledTimes(1);
|
||
expect(deletionCommitted).toBe(false);
|
||
expect(deleteMessages).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it.each(['terminalPersistencePending', 'terminalHostActionPending'])(
|
||
'drains %s only for leases removed by this deletion',
|
||
async (marker) => {
|
||
const createdAt = Date.now();
|
||
deleteConvos.mockResolvedValue({
|
||
deletedCount: 2,
|
||
conversationIds: ['parent-conversation', 'child-conversation'],
|
||
});
|
||
subagentThreadStore.planCancellationForConversations.mockResolvedValueOnce({
|
||
userId: 'test-user-123',
|
||
conversationIds: ['parent-conversation'],
|
||
scopes: [],
|
||
leases: [
|
||
{
|
||
taskId: 'related-generation',
|
||
parentConversationId: 'parent-conversation',
|
||
conversationId: 'child-conversation',
|
||
},
|
||
{
|
||
taskId: 'unrelated-generation',
|
||
parentConversationId: 'other-parent',
|
||
conversationId: 'other-child',
|
||
},
|
||
],
|
||
});
|
||
let relatedReads = 0;
|
||
generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => {
|
||
if (conversationId !== 'related-generation') return null;
|
||
relatedReads += 1;
|
||
return {
|
||
status: 'complete',
|
||
createdAt,
|
||
metadata: {
|
||
userId: 'test-user-123',
|
||
providerDrained: true,
|
||
[marker]: relatedReads <= 2,
|
||
},
|
||
};
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({ arg: { conversationId: 'parent-conversation' } });
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(generationJobManager.abortJob).toHaveBeenCalledWith('related-generation', {
|
||
expectedCreatedAt: createdAt,
|
||
awaitProviderDrain: true,
|
||
});
|
||
expect(relatedReads).toBeGreaterThanOrEqual(3);
|
||
expect(generationJobManager.getCleanupJob).not.toHaveBeenCalledWith('unrelated-generation');
|
||
expect(deleteConvos).toHaveBeenCalledTimes(2);
|
||
},
|
||
);
|
||
|
||
it('should delete a single conversation, tool calls, and associated shared links', async () => {
|
||
const mockConversationId = 'conv-123';
|
||
const mockDbResponse = {
|
||
deletedCount: 1,
|
||
message: 'Conversation deleted successfully',
|
||
};
|
||
|
||
deleteConvos.mockResolvedValue(mockDbResponse);
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 3 });
|
||
deleteConvoSharedLinksWithCleanup.mockResolvedValue({
|
||
message: 'Shared links deleted successfully',
|
||
deletedCount: 1,
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({
|
||
arg: {
|
||
conversationId: mockConversationId,
|
||
},
|
||
});
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(response.body).toMatchObject(mockDbResponse);
|
||
|
||
/** Verify deleteConvos was called with correct parameters */
|
||
expect(deleteConvos).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
{ conversationId: mockConversationId },
|
||
expect.objectContaining({ beforeDelete: expect.any(Function) }),
|
||
);
|
||
|
||
/** Verify deleteToolCalls was called */
|
||
expect(deleteToolCalls).toHaveBeenCalledWith('test-user-123', mockConversationId);
|
||
|
||
/** Verify deleteConvoSharedLinksWithCleanup was called */
|
||
expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
mockConversationId,
|
||
);
|
||
});
|
||
|
||
it('should not call deleteConvoSharedLinksWithCleanup when no conversationId provided', async () => {
|
||
deleteConvos.mockResolvedValue({ deletedCount: 0 });
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 0 });
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({
|
||
arg: {
|
||
source: 'button',
|
||
},
|
||
});
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(deleteConvoSharedLinksWithCleanup).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should handle deletion of conversation without shared links', async () => {
|
||
const mockConversationId = 'conv-no-shares';
|
||
|
||
deleteConvos.mockResolvedValue({ deletedCount: 1 });
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 0 });
|
||
deleteConvoSharedLinksWithCleanup.mockResolvedValue({
|
||
message: 'Shared links deleted successfully',
|
||
deletedCount: 0,
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({
|
||
arg: {
|
||
conversationId: mockConversationId,
|
||
},
|
||
});
|
||
|
||
expect(response.status).toBe(201);
|
||
expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
mockConversationId,
|
||
);
|
||
});
|
||
|
||
it('should return 400 when no parameters provided', async () => {
|
||
const response = await request(app).delete('/api/convos').send({
|
||
arg: {},
|
||
});
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual({ error: 'no parameters provided' });
|
||
expect(deleteConvos).not.toHaveBeenCalled();
|
||
expect(deleteConvoSharedLinksWithCleanup).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 400 when request body is empty (DoS prevention)', async () => {
|
||
const response = await request(app).delete('/api/convos').send({});
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual({ error: 'no parameters provided' });
|
||
expect(deleteConvos).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 400 when arg is null (DoS prevention)', async () => {
|
||
const response = await request(app).delete('/api/convos').send({ arg: null });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual({ error: 'no parameters provided' });
|
||
expect(deleteConvos).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 400 when arg is undefined (DoS prevention)', async () => {
|
||
const response = await request(app).delete('/api/convos').send({ arg: undefined });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual({ error: 'no parameters provided' });
|
||
expect(deleteConvos).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 400 when request body is null (DoS prevention)', async () => {
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.set('Content-Type', 'application/json')
|
||
.send('null');
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(deleteConvos).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 500 if deleteConvoSharedLinksWithCleanup fails', async () => {
|
||
const mockConversationId = 'conv-error';
|
||
|
||
deleteConvos.mockResolvedValue({ deletedCount: 1 });
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 2 });
|
||
deleteConvoSharedLinksWithCleanup.mockRejectedValue(
|
||
new Error('Failed to delete shared links'),
|
||
);
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({
|
||
arg: {
|
||
conversationId: mockConversationId,
|
||
},
|
||
});
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.text).toBe('Error clearing conversations');
|
||
});
|
||
|
||
it('should execute deletions in correct sequence for single conversation', async () => {
|
||
const mockConversationId = 'conv-sequence';
|
||
const executionOrder = [];
|
||
|
||
deleteConvos.mockImplementation(() => {
|
||
executionOrder.push('deleteConvos');
|
||
return Promise.resolve({ deletedCount: 1 });
|
||
});
|
||
|
||
deleteToolCalls.mockImplementation(() => {
|
||
executionOrder.push('deleteToolCalls');
|
||
return Promise.resolve({ deletedCount: 2 });
|
||
});
|
||
|
||
deleteConvoSharedLinksWithCleanup.mockImplementation(() => {
|
||
executionOrder.push('deleteConvoSharedLinksWithCleanup');
|
||
return Promise.resolve({ deletedCount: 1 });
|
||
});
|
||
|
||
await request(app)
|
||
.delete('/api/convos')
|
||
.send({
|
||
arg: {
|
||
conversationId: mockConversationId,
|
||
},
|
||
});
|
||
|
||
expect(executionOrder).toEqual([
|
||
'deleteConvos',
|
||
'deleteConvos',
|
||
'deleteToolCalls',
|
||
'deleteConvoSharedLinksWithCleanup',
|
||
]);
|
||
});
|
||
|
||
it('should prevent orphaned shared links when deleting single conversation', async () => {
|
||
const mockConversationId = 'conv-with-shares';
|
||
|
||
deleteConvos.mockResolvedValue({ deletedCount: 1 });
|
||
deleteToolCalls.mockResolvedValue({ deletedCount: 4 });
|
||
deleteConvoSharedLinksWithCleanup.mockResolvedValue({
|
||
message: 'Shared links deleted successfully',
|
||
deletedCount: 2,
|
||
});
|
||
|
||
const response = await request(app)
|
||
.delete('/api/convos')
|
||
.send({
|
||
arg: {
|
||
conversationId: mockConversationId,
|
||
},
|
||
});
|
||
|
||
expect(response.status).toBe(201);
|
||
|
||
/** Verify shared links were deleted for the specific conversation */
|
||
expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
mockConversationId,
|
||
);
|
||
|
||
/** Verify it was called after the conversation was deleted */
|
||
expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledAfter(deleteConvos);
|
||
});
|
||
});
|
||
|
||
describe('GET / search handling', () => {
|
||
const { getConvosByCursor } = require('~/models');
|
||
|
||
beforeEach(() => {
|
||
getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null });
|
||
});
|
||
|
||
/** Express already percent-decodes `req.query`, so decoding a second time in the route
|
||
* threw URIError on any term containing a bare `%` and mangled `%xx`-looking text. */
|
||
it('accepts a search term containing a literal percent sign', async () => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query({ isArchived: 'true', search: '100% ready' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ search: '100% ready' }),
|
||
);
|
||
});
|
||
|
||
it('passes percent-escape-looking text through without decoding it', async () => {
|
||
const response = await request(app).get('/api/convos').query({ search: 'a%41b' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ search: 'a%41b' }),
|
||
);
|
||
});
|
||
|
||
it('treats a whitespace-only search as no search', async () => {
|
||
const response = await request(app).get('/api/convos').query({ search: ' ' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ search: undefined }),
|
||
);
|
||
});
|
||
});
|
||
|
||
describe('GET / pinned filter', () => {
|
||
const { getConvosByCursor } = require('~/models');
|
||
|
||
beforeEach(() => {
|
||
getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null });
|
||
});
|
||
|
||
it('forwards pinned=true so the sidebar section can fetch pins on their own', async () => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query({ pinned: 'true', limit: '100' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ pinned: true, limit: 100 }),
|
||
);
|
||
});
|
||
|
||
it('leaves the list unfiltered when pinned is absent', async () => {
|
||
const response = await request(app).get('/api/convos');
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ pinned: false }),
|
||
);
|
||
});
|
||
});
|
||
|
||
describe('GET / limit clamping', () => {
|
||
const { getConvosByCursor } = require('~/models');
|
||
|
||
beforeEach(() => {
|
||
getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null });
|
||
});
|
||
|
||
/** `parseInt('-1') || 25` kept the -1, and `.limit(-1 + 1)` is `.limit(0)`, which
|
||
* MongoDB reads as "no limit" — one request drained the caller's whole list. */
|
||
it('clamps a negative limit instead of forwarding it', async () => {
|
||
const response = await request(app).get('/api/convos').query({ limit: '-1' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ limit: 1 }),
|
||
);
|
||
});
|
||
|
||
it('caps an oversized limit at the page ceiling', async () => {
|
||
const response = await request(app).get('/api/convos').query({ limit: '999999999' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ limit: 100 }),
|
||
);
|
||
});
|
||
|
||
it('raises a zero limit to a single row', async () => {
|
||
const response = await request(app).get('/api/convos').query({ limit: '0' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ limit: 1 }),
|
||
);
|
||
});
|
||
|
||
it.each([
|
||
['absent', undefined],
|
||
['non-numeric', 'all'],
|
||
])('falls back to the default page size when the limit is %s', async (_label, limit) => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query(limit === undefined ? {} : { limit });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ limit: 25 }),
|
||
);
|
||
});
|
||
|
||
/** Express parses a repeated key into an array, which `parseInt` silently reads as
|
||
* its first element's digits rather than rejecting. */
|
||
it('clamps a repeated limit parameter', async () => {
|
||
const response = await request(app).get('/api/convos?limit=999999&limit=5');
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ limit: 100 }),
|
||
);
|
||
});
|
||
});
|
||
|
||
describe('GET / list facets', () => {
|
||
const { getConvosByCursor } = require('~/models');
|
||
const { getAppConfig } = require('~/server/services/Config');
|
||
|
||
beforeEach(() => {
|
||
getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null });
|
||
});
|
||
|
||
it('forwards the date cutoffs as dates', async () => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query({ updatedAfter: '2026-09-01T00:00:00.000Z' });
|
||
|
||
expect(response.status).toBe(200);
|
||
const [, options] = getConvosByCursor.mock.calls.at(-1);
|
||
expect(options.updatedAfter).toBeInstanceOf(Date);
|
||
expect(options.updatedAfter.toISOString()).toBe('2026-09-01T00:00:00.000Z');
|
||
});
|
||
|
||
it('forwards repeated endpoint params as one list', async () => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query('endpoints=openAI&endpoints=agents');
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ endpoints: ['openAI', 'agents'] }),
|
||
);
|
||
});
|
||
|
||
it('forwards the attachment flag only when it is on', async () => {
|
||
await request(app).get('/api/convos').query({ hasFiles: 'true' });
|
||
expect(getConvosByCursor).toHaveBeenLastCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ hasFiles: true }),
|
||
);
|
||
|
||
await request(app).get('/api/convos').query({ hasFiles: 'false' });
|
||
const [, options] = getConvosByCursor.mock.calls.at(-1);
|
||
expect(options.hasFiles).toBeUndefined();
|
||
});
|
||
|
||
/** Dropping a filter the caller sent would answer with conversations they asked
|
||
* to exclude, which is worse than refusing the request. */
|
||
it('refuses a malformed cutoff instead of listing unfiltered', async () => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query({ updatedAfter: 'last tuesday' });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body.error).toMatch(/updatedAfter/);
|
||
expect(getConvosByCursor).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('refuses a mistyped flag instead of listing unfiltered', async () => {
|
||
const response = await request(app).get('/api/convos').query({ hasFiles: 'tru' });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body.error).toMatch(/hasFiles/);
|
||
expect(getConvosByCursor).not.toHaveBeenCalled();
|
||
});
|
||
|
||
/** The limits are deployment-level, so the list reads the base config instead of
|
||
* resolving the caller's merged config on every sidebar request. */
|
||
it('enforces the endpoint limit the deployment configures', async () => {
|
||
const query = 'endpoints=openAI&endpoints=agents&endpoints=google';
|
||
|
||
const withinDefault = await request(app).get('/api/convos').query(query);
|
||
expect(withinDefault.status).toBe(200);
|
||
|
||
getAppConfig.mockResolvedValueOnce({
|
||
conversationList: { maxEndpointFilters: 2, maxEndpointNameLength: 128 },
|
||
});
|
||
const overConfigured = await request(app).get('/api/convos').query(query);
|
||
expect(overConfigured.status).toBe(400);
|
||
expect(overConfigured.body.error).toMatch(/at most 2 names/);
|
||
});
|
||
|
||
it('answers the route error when an endpoint filter cannot read its limits', async () => {
|
||
getAppConfig.mockRejectedValueOnce(new Error('config unavailable'));
|
||
|
||
const response = await request(app).get('/api/convos').query({ endpoints: 'openAI' });
|
||
|
||
expect(response.status).toBe(500);
|
||
expect(response.body.error).toBe('Error fetching conversations');
|
||
expect(getConvosByCursor).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('forwards the shared flag only when it is on', async () => {
|
||
await request(app).get('/api/convos').query({ sharedOnly: 'true' });
|
||
expect(getConvosByCursor).toHaveBeenLastCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ sharedOnly: true }),
|
||
);
|
||
|
||
await request(app).get('/api/convos').query({ sharedOnly: 'false' });
|
||
const [, options] = getConvosByCursor.mock.calls.at(-1);
|
||
expect(options.sharedOnly).toBeUndefined();
|
||
});
|
||
|
||
it('sends no facet keys when the request carries none', async () => {
|
||
await request(app).get('/api/convos');
|
||
|
||
const [, options] = getConvosByCursor.mock.calls.at(-1);
|
||
expect(options.updatedAfter).toBeUndefined();
|
||
expect(options.createdAfter).toBeUndefined();
|
||
expect(options.endpoints).toBeUndefined();
|
||
expect(options.hasFiles).toBeUndefined();
|
||
expect(options.sharedOnly).toBeUndefined();
|
||
});
|
||
});
|
||
|
||
describe('GET / sort normalization', () => {
|
||
const { getConvosByCursor } = require('~/models');
|
||
|
||
beforeEach(() => {
|
||
getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null });
|
||
});
|
||
|
||
it('forwards a whitelisted sort field and direction', async () => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query({ sortBy: 'title', sortDirection: 'asc' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ sortBy: 'title', sortDirection: 'asc' }),
|
||
);
|
||
});
|
||
|
||
/** An unknown field reaches `getConvosByCursor`, which throws on it, so forwarding
|
||
* a stale or hand-edited value would answer 500 instead of listing anything. */
|
||
it('falls back to the default ordering for values it does not recognize', async () => {
|
||
const response = await request(app)
|
||
.get('/api/convos')
|
||
.query({ sortBy: 'DROP TABLE', sortDirection: 'sideways' });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(getConvosByCursor).toHaveBeenCalledWith(
|
||
'test-user-123',
|
||
expect.objectContaining({ sortBy: 'updatedAt', sortDirection: 'desc' }),
|
||
);
|
||
});
|
||
});
|
||
|
||
describe('POST /seen', () => {
|
||
/* The handler's own validation and error mapping live in `packages/api` and are covered
|
||
against the real implementation there; what matters here is that the route reaches it
|
||
with the authenticated user. */
|
||
it('routes to the handler for the authenticated user', async () => {
|
||
markConvoSeen.mockResolvedValue({ modified: true });
|
||
|
||
const response = await request(app)
|
||
.post('/api/convos/seen')
|
||
.send({ arg: { conversationId: 'conv-seen-1' } });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(response.body).toEqual({ modified: true });
|
||
expect(markConvoSeen).toHaveBeenCalledWith('test-user-123', 'conv-seen-1');
|
||
});
|
||
});
|
||
|
||
describe('POST /unread', () => {
|
||
it('routes to the handler for the authenticated user', async () => {
|
||
markConvoUnread.mockResolvedValue({ modified: true });
|
||
|
||
const response = await request(app)
|
||
.post('/api/convos/unread')
|
||
.send({ arg: { conversationId: 'conv-unread-1' } });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(response.body).toEqual({ modified: true });
|
||
expect(markConvoUnread).toHaveBeenCalledWith('test-user-123', 'conv-unread-1');
|
||
});
|
||
});
|
||
|
||
describe('POST /update running chat rename', () => {
|
||
it('delegates rename semantics to the injected TypeScript handler', async () => {
|
||
const { renameConversationHandler, renameHandlerInputs } = require(MOCKS);
|
||
const arg = { conversationId: 'running-rename', title: 'Renamed' };
|
||
expect((await request(app).post('/api/convos/update').send({ arg })).status).toBe(204);
|
||
expect(renameConversationHandler).toHaveBeenCalledWith(
|
||
expect.objectContaining({
|
||
body: { arg },
|
||
user: expect.objectContaining({ id: 'test-user-123' }),
|
||
}),
|
||
expect.anything(),
|
||
expect.anything(),
|
||
);
|
||
expect(renameHandlerInputs.at(-1)).toEqual(
|
||
expect.objectContaining({
|
||
saveConvo,
|
||
getConvo,
|
||
getActiveRunIds: expect.any(Function),
|
||
logger: expect.anything(),
|
||
}),
|
||
);
|
||
});
|
||
});
|
||
|
||
describe('POST /archive', () => {
|
||
const { configMiddleware, validateConvoAccess } = require('~/server/middleware');
|
||
const { archiveConversationHandler, archiveHandlerInputs } = require(MOCKS);
|
||
const { getConvoRetention } = require('~/models');
|
||
const interfaceConfig = { retentionMode: 'ephemeral', temporaryChatRetention: 24 };
|
||
const archiveRequest = { arg: { conversationId: 'conv-retention', isArchived: true } };
|
||
const order = [];
|
||
let configSeenByAccessCheck;
|
||
let configSeenByHandler;
|
||
|
||
/** Nothing mounts the config ahead of the convos router, so the route has to load it:
|
||
* without `interfaceConfig` the retention rules in `saveConvo` never see a mode. */
|
||
beforeEach(() => {
|
||
order.length = 0;
|
||
configSeenByAccessCheck = undefined;
|
||
configSeenByHandler = undefined;
|
||
configMiddleware.mockImplementation((req, res, next) => {
|
||
order.push('config');
|
||
req.config = { ...req.config, interfaceConfig };
|
||
next();
|
||
});
|
||
validateConvoAccess.mockImplementation((req, res, next) => {
|
||
order.push('access');
|
||
configSeenByAccessCheck = req.config?.interfaceConfig;
|
||
next();
|
||
});
|
||
archiveConversationHandler.mockImplementation((req, res) => {
|
||
order.push('handler');
|
||
configSeenByHandler = req.config?.interfaceConfig;
|
||
return res.status(200).json({ conversationId: 'conv-retention' });
|
||
});
|
||
});
|
||
|
||
afterEach(() => {
|
||
configMiddleware.mockImplementation((req, res, next) => next());
|
||
validateConvoAccess.mockImplementation((req, res, next) => next());
|
||
archiveConversationHandler.mockImplementation((_req, res) => res.status(200).json({}));
|
||
});
|
||
|
||
it('serves the archive handler with the conversation store', () => {
|
||
expect(archiveHandlerInputs.at(-1)).toEqual({ saveConvo, getConvoRetention });
|
||
});
|
||
|
||
it('loads the config before the access check, which reads the retention mode from it', async () => {
|
||
const response = await request(app).post('/api/convos/archive').send(archiveRequest);
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(order).toEqual(['config', 'access', 'handler']);
|
||
expect(configSeenByAccessCheck).toEqual(interfaceConfig);
|
||
});
|
||
|
||
it('hands the loaded config to the handler', async () => {
|
||
await request(app).post('/api/convos/archive').send(archiveRequest);
|
||
|
||
expect(configSeenByHandler).toEqual(interfaceConfig);
|
||
});
|
||
});
|
||
|
||
describe('POST /archive/all', () => {
|
||
const { archiveAllConvos } = require('~/models');
|
||
|
||
it('delegates archive-all requests through the package API handler', async () => {
|
||
archiveAllConvos.mockResolvedValue({ archivedCount: 4 });
|
||
|
||
const response = await request(app).post('/api/convos/archive/all');
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(response.body).toEqual({ archivedCount: 4 });
|
||
expect(archiveAllHandler).toHaveBeenCalledTimes(1);
|
||
expect(archiveAllConvos).toHaveBeenCalledWith('test-user-123');
|
||
});
|
||
});
|
||
|
||
describe('POST /convos/pin', () => {
|
||
const mockConversationId = 'conv-123';
|
||
const { setConvoPinned } = require('~/models');
|
||
|
||
it('should pin a conversation', async () => {
|
||
const mockPinnedConvo = { conversationId: mockConversationId, pinned: true };
|
||
setConvoPinned.mockResolvedValue(mockPinnedConvo);
|
||
|
||
const response = await request(app).post('/api/convos/pin').send({ arg: mockPinnedConvo });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(response.body).toEqual(mockPinnedConvo);
|
||
expect(setConvoPinned).toHaveBeenCalledWith('test-user-123', mockConversationId, true);
|
||
});
|
||
|
||
it('should unpin a conversation', async () => {
|
||
const mockUnpinnedConvo = { conversationId: mockConversationId, pinned: false };
|
||
setConvoPinned.mockResolvedValue(mockUnpinnedConvo);
|
||
|
||
const response = await request(app).post('/api/convos/pin').send({ arg: mockUnpinnedConvo });
|
||
|
||
expect(response.status).toBe(200);
|
||
expect(response.body).toEqual(mockUnpinnedConvo);
|
||
expect(setConvoPinned).toHaveBeenCalledWith('test-user-123', mockConversationId, false);
|
||
});
|
||
|
||
/** A pin is one boolean: it must not drag in `saveConvo`'s message-id refresh
|
||
* and project-stats recompute, which cost an extra read and a large write. */
|
||
it('does not route a pin through the full conversation save', async () => {
|
||
setConvoPinned.mockResolvedValue({ conversationId: mockConversationId, pinned: true });
|
||
|
||
await request(app)
|
||
.post('/api/convos/pin')
|
||
.send({ arg: { conversationId: mockConversationId, pinned: true } });
|
||
|
||
expect(setConvoPinned).toHaveBeenCalledTimes(1);
|
||
expect(saveConvo).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 404 when the conversation does not exist', async () => {
|
||
setConvoPinned.mockResolvedValue(null);
|
||
|
||
const response = await request(app)
|
||
.post('/api/convos/pin')
|
||
.send({ arg: { conversationId: 'missing-convo', pinned: true } });
|
||
|
||
expect(response.status).toBe(404);
|
||
expect(response.body).toEqual({ error: 'Conversation not found' });
|
||
});
|
||
|
||
it('should return 400 when conversationId is missing', async () => {
|
||
const response = await request(app)
|
||
.post('/api/convos/pin')
|
||
.send({ arg: { pinned: true } });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual({ error: 'conversationId is required' });
|
||
expect(setConvoPinned).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 400 when pinned is not a boolean', async () => {
|
||
const response = await request(app)
|
||
.post('/api/convos/pin')
|
||
.send({ arg: { conversationId: mockConversationId, pinned: 'yes' } });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual({ error: 'pinned must be a boolean' });
|
||
expect(setConvoPinned).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 400 when pinned is missing', async () => {
|
||
const response = await request(app)
|
||
.post('/api/convos/pin')
|
||
.send({ arg: { conversationId: mockConversationId } });
|
||
|
||
expect(response.status).toBe(400);
|
||
expect(response.body).toEqual({ error: 'pinned is required' });
|
||
expect(setConvoPinned).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('should return 500 when the pin update fails', async () => {
|
||
setConvoPinned.mockRejectedValue(new Error('Database error'));
|
||
|
||
const response = await request(app)
|
||
.post('/api/convos/pin')
|
||
.send({ arg: { conversationId: mockConversationId, pinned: true } });
|
||
|
||
expect(response.status).toBe(500);
|
||
});
|
||
});
|
||
});
|
||
|
||
/**
|
||
* Custom Jest matcher to verify function call order
|
||
*/
|
||
expect.extend({
|
||
toHaveBeenCalledAfter(received, other) {
|
||
const receivedCalls = received.mock.invocationCallOrder;
|
||
const otherCalls = other.mock.invocationCallOrder;
|
||
|
||
if (receivedCalls.length === 0) {
|
||
return {
|
||
pass: false,
|
||
message: () =>
|
||
`Expected ${received.getMockName()} to have been called after ${other.getMockName()}, but ${received.getMockName()} was never called`,
|
||
};
|
||
}
|
||
|
||
if (otherCalls.length === 0) {
|
||
return {
|
||
pass: false,
|
||
message: () =>
|
||
`Expected ${received.getMockName()} to have been called after ${other.getMockName()}, but ${other.getMockName()} was never called`,
|
||
};
|
||
}
|
||
|
||
const lastReceivedCall = receivedCalls[receivedCalls.length - 1];
|
||
const firstOtherCall = otherCalls[0];
|
||
|
||
const pass = lastReceivedCall > firstOtherCall;
|
||
|
||
return {
|
||
pass,
|
||
message: () =>
|
||
pass
|
||
? `Expected ${received.getMockName()} not to have been called after ${other.getMockName()}`
|
||
: `Expected ${received.getMockName()} to have been called after ${other.getMockName()}`,
|
||
};
|
||
},
|
||
});
|