LibreChat/api/server/routes/agents/__tests__/events.spec.js
Marco Beretta 79b836d79f
📃 fix: Enforce Terms Acceptance on the Server and Mark Backfilled Consent (#17063)
* fix: Enforce Terms Acceptance on the Server When modalAcceptance Is On

* fix: Mark Backfilled Terms Acceptance Timestamps

* test: Cover Server-Enforced Terms Acceptance in the Mock Harness

* fix: Gate Management Routes and Skill Sync and Resolve Terms Policy Fail-Closed

* fix: Evict Cached Auth Documents When Terms Acceptance Is Reset

* fix: Guard Skill Sync Behind Terms Acceptance for Every Skill List Route

* fix: Move Terms Skill-Sync Guard Into the API Package and Evict All Users on Reset

* fix: Batch Terms Reset Cache Eviction and Sign the Spec User In Fresh

* fix: Let Stop Through the Terms Gate, Refresh Startup Config, and Wait Out Failed Eviction

* refactor: Narrow the Terms Exemptions and Share One Refusal Path Across Clients

* refactor: Compose the JWT Terms Gate Through an API Package Helper

* style: Sort Imports for the Shared Terms Refusal Helper

* test: Expose the Terms Gate Helper in the JWT Auth Spec Mock

* test: Cover the Terms Refusal Code on Pre-Stream Upload Errors
2026-10-14 17:45:28 +02:00

107 lines
3.4 KiB
JavaScript

const express = require('express');
const request = require('supertest');
const mockEnqueueAgentTrigger = jest.fn();
const mockGetAgentTriggerDeliveryStatus = jest.fn();
const mockEnqueueEvent = jest.fn((_req, res) => res.status(202).json({ id: 'trigger-1' }));
const mockGetEvent = jest.fn((_req, res) => res.status(200).json({ status: 'succeeded' }));
const mockRegisterBinding = jest.fn((_req, res) => res.status(201).json({ id: 'evtbind-1' }));
const mockResolveBinding = jest.fn((_req, _res, next) => next());
let mockIngressDependencies;
const mockCreateAgentTriggerIngressHandlers = jest.fn((dependencies) => {
mockIngressDependencies = dependencies;
return {
enqueueEvent: mockEnqueueEvent,
getEvent: mockGetEvent,
};
});
jest.mock('@librechat/api', () => ({
createAgentEventBindingHandlers: () => ({
register: mockRegisterBinding,
resolve: mockResolveBinding,
}),
createAgentTriggerIngressHandlers: mockCreateAgentTriggerIngressHandlers,
createMessageFilterPii: () => (_req, _res, next) => next(),
}));
jest.mock('~/models', () => ({
getAgent: jest.fn(),
getConvo: jest.fn(),
getAgentEventBinding: jest.fn(),
reserveSubagentThread: jest.fn(),
}));
jest.mock('~/server/controllers/agents/openai', () => ({
OpenAIChatCompletionController: jest.fn(),
ListModelsController: jest.fn(),
GetModelController: jest.fn(),
}));
jest.mock('~/server/services/Agents/triggers', () => ({
enqueueAgentTrigger: mockEnqueueAgentTrigger,
getAgentTriggerDeliveryStatus: mockGetAgentTriggerDeliveryStatus,
}));
jest.mock('~/server/middleware', () => ({
agentEventUserLimiter: (_req, _res, next) => next(),
configMiddleware: (_req, _res, next) => next(),
requireTermsAcceptance: (_req, _res, next) => next(),
}));
jest.mock('../middleware', () => ({
preAuthTenantMiddleware: (_req, _res, next) => next(),
requireRemoteAgentAuth: (req, _res, next) => {
req.user = { id: 'user-1' };
next();
},
checkRemoteAgentsFeature: (_req, _res, next) => next(),
checkAgentPermission: (_req, _res, next) => next(),
checkAgentTriggerPermission: (_req, _res, next) => next(),
}));
const router = require('../openai');
describe('Remote Agents event routes', () => {
const app = express();
app.use(express.json());
app.use('/api/agents/v1', router);
beforeEach(() => {
mockEnqueueEvent.mockClear();
mockGetEvent.mockClear();
mockRegisterBinding.mockClear();
mockResolveBinding.mockClear();
});
it('registers a source-bound child actor thread', async () => {
const response = await request(app)
.post('/api/agents/v1/events/bindings')
.send({ target: { agentId: 'agent-1' } });
expect(response.status).toBe(201);
expect(mockRegisterBinding).toHaveBeenCalledTimes(1);
});
it('wires durable event admission to the trigger service', async () => {
const response = await request(app)
.post('/api/agents/v1/events')
.send({
target: { agentId: 'agent-1' },
});
expect(response.status).toBe(202);
expect(mockIngressDependencies).toEqual({
enqueue: mockEnqueueAgentTrigger,
getDeliveryStatus: mockGetAgentTriggerDeliveryStatus,
});
expect(mockEnqueueEvent).toHaveBeenCalledTimes(1);
});
it('wires owner-scoped event status reads to the ingress handler', async () => {
const response = await request(app).get('/api/agents/v1/events/trigger-1');
expect(response.status).toBe(200);
expect(mockGetEvent).toHaveBeenCalledTimes(1);
});
});