Files
crosscode-platform/apps/events/backend/tests/ai.test.ts
T
joshuaandClaude Opus 5.5 38ebce24ab Events: AI use in tokens, not rand (for 2.3.0); contracts: token fields on the AI status
Site settings → AI, the usage tables and the 80% email show input/output
tokens and the percentage; the rand amounts from the Hub are dropped on
arrival. AiCall stores each call's tokens (migration ai_tokens). v2
/ai/status and /ai/usage carry tokens instead of cents. Needs Hub 2.0.1
for the token figures; older Hubs show the percentage only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 10:59:36 +02:00

157 lines
8.5 KiB
TypeScript

// AI helpers (2.0): what the buttons do, and how a helper call goes through the Hub (§3b).
const mockCalls: Array<Record<string, unknown>> = [];
const mockSettings = new Map<string, string>();
const mockDb = {
appSetting: {
findUnique: jest.fn(async ({ where }: { where: { key: string } }) => (mockSettings.has(where.key) ? { key: where.key, value: mockSettings.get(where.key) } : null)),
upsert: jest.fn(async ({ where, update }: { where: { key: string }; update: { value: string } }) => { mockSettings.set(where.key, update.value); }),
},
aiCall: {
count: jest.fn(async () => mockCalls.filter(c => c.outcome === 'ok').length),
create: jest.fn(async ({ data }: { data: Record<string, unknown> }) => { mockCalls.push(data); return data; }),
deleteMany: jest.fn(async () => ({ count: 0 })),
},
user: { findMany: jest.fn(async () => [{ email: 'admin@test.local' }]) },
};
jest.mock('../src/config/db', () => mockDb);
const mockLicence = { connected: true, readOnly: false, state: 'active', claims: { limits: { aiMonthlyCapCents: 5000 } } as { limits: { aiMonthlyCapCents: number } } | null };
jest.mock('../src/hub/licence', () => ({ licenceStatus: jest.fn(async () => mockLicence) }));
class MockHubError extends Error {
constructor(message: string, public code: string, public statusCode: number, public data: unknown = null) { super(message); }
}
const mockPost = jest.fn();
jest.mock('../src/hub/client', () => ({ PROTOCOL_VERSION: 1, HubError: MockHubError, signedPost: (...a: unknown[]) => mockPost(...a) }));
const mockMail = jest.fn(async (_m: unknown) => undefined);
jest.mock('../src/utils/email', () => ({ sendMail: (m: unknown) => mockMail(m), emailWrapper: (s: string) => s, isSmtpConfigured: () => true }));
jest.mock('../src/utils/adminAudit', () => ({ logAdminAction: jest.fn(async () => undefined) }));
import { aiStatus, runHelper, saveAiSettings, clearAiStatusCache, tokenText, _internal } from '../src/ai';
const hubStatus = (over = {}) => ({
enabled: true, capReached: false, capCents: 5000, usedCents: 100, usedPercent: 2, renewsOn: '2026-12-01',
usedInputTokens: 40000, usedOutputTokens: 9000, capInputTokens: 1785000, capOutputTokens: 357000, ...over,
});
const req = { system: 'Write a friendly message.', input: 'Bring a sleeping bag.', maxTokens: 500 };
beforeEach(() => {
mockCalls.length = 0;
mockSettings.clear();
mockPost.mockReset();
mockMail.mockClear();
mockLicence.connected = true;
mockLicence.readOnly = false;
mockLicence.claims = { limits: { aiMonthlyCapCents: 5000 } };
clearAiStatusCache();
});
describe('status', () => {
test('a licence without AI never asks the Hub', async () => {
mockLicence.claims = { limits: { aiMonthlyCapCents: 0 } };
expect(await aiStatus()).toMatchObject({ enabled: false, capReached: false });
mockLicence.connected = false;
expect((await aiStatus()).enabled).toBe(false);
expect(mockPost).not.toHaveBeenCalled();
});
test('asks the Hub and caches its answer for a minute', async () => {
mockPost.mockResolvedValue(hubStatus());
expect(await aiStatus()).toMatchObject({ enabled: true, available: true, usedInputTokens: 40000, capOutputTokens: 357000, helpers: { draft_event: true } });
await aiStatus();
expect(mockPost).toHaveBeenCalledTimes(1);
expect(mockPost).toHaveBeenCalledWith('/api/installs/ai/status', { protocolVersion: 1 });
});
test('a Hub without AI (404) means off; an unreachable Hub keeps the buttons, marked unavailable', async () => {
mockPost.mockRejectedValueOnce(new MockHubError('Not found', 'NOT_FOUND', 404));
expect((await aiStatus()).enabled).toBe(false);
clearAiStatusCache();
mockPost.mockRejectedValueOnce(new MockHubError('down', 'HUB_UNREACHABLE', 502));
expect(await aiStatus()).toMatchObject({ enabled: true, available: false });
});
test('the Hub\'s rand amounts never leave the site (2.3.0); a Hub before 2.0.1 sends no tokens', async () => {
mockPost.mockResolvedValueOnce(hubStatus());
const s = await aiStatus() as unknown as Record<string, unknown>;
expect(s).not.toHaveProperty('capCents');
expect(s).not.toHaveProperty('usedCents');
clearAiStatusCache();
mockPost.mockResolvedValueOnce({ enabled: true, capReached: false, capCents: 5000, usedCents: 100, usedPercent: 2, renewsOn: '2026-12-01' });
expect(await aiStatus()).toMatchObject({ usedPercent: 2, usedInputTokens: null, capInputTokens: null });
});
test('tokens for people', () => {
expect(['800', '45K', '1.2M', '2M', '12M']).toEqual([800, 45000, 1200000, 2000000, 12300000].map(tokenText));
});
});
describe('running a helper', () => {
test('sends the request to the Hub, logs the call, returns the answer', async () => {
mockPost.mockResolvedValueOnce(hubStatus()).mockResolvedValueOnce({
output: 'Hi all!', usage: { inputTokens: 1840, outputTokens: 420 }, chargedCents: 0.31, status: hubStatus({ usedInputTokens: 41840, usedOutputTokens: 9420 }),
});
const r = await runHelper('draft_message', 'u1', req);
expect(r.output).toBe('Hi all!');
expect(r.status).toMatchObject({ usedInputTokens: 41840, usedOutputTokens: 9420 });
expect(mockPost).toHaveBeenLastCalledWith('/api/installs/ai/complete', { protocolVersion: 1, helper: 'draft_message', ...req }, { timeoutMs: 90000 });
expect(mockCalls).toEqual([{ userId: 'u1', helper: 'draft_message', outcome: 'ok', chargedCents: 0.31, inputTokens: 1840, outputTokens: 420 }]);
});
test('a helper switched off, or the cap reached, never reaches the Hub', async () => {
mockPost.mockResolvedValue(hubStatus({ capReached: true }));
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ code: 'FORBIDDEN', reason: 'AI_CAP_REACHED' });
clearAiStatusCache();
mockPost.mockResolvedValue(hubStatus());
await saveAiSettings({ helpers: { draft_message: false } }, { id: 'a1', role: 'admin' });
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ reason: 'AI_HELPER_OFF' });
expect(mockPost).not.toHaveBeenCalledWith('/api/installs/ai/complete', expect.anything(), expect.anything());
});
test('the per-person daily limit', async () => {
await saveAiSettings({ dailyLimitPerPerson: 1 }, { id: 'a1', role: 'admin' });
mockPost.mockResolvedValueOnce(hubStatus()).mockResolvedValueOnce({ output: 'x', chargedCents: 0.1, status: hubStatus() });
await runHelper('draft_message', 'u1', req);
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ code: 'RATE_LIMITED', reason: 'AI_DAILY_LIMIT' });
});
test('the Hub refusing at the cap updates the status, so the buttons disable at once', async () => {
mockPost.mockResolvedValueOnce(hubStatus())
.mockRejectedValueOnce(new MockHubError('used up', 'AI_CAP_REACHED', 402, { code: 'AI_CAP_REACHED', status: hubStatus({ capReached: true }) }));
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ reason: 'AI_CAP_REACHED', message: expect.stringContaining('1 December') });
expect((await aiStatus()).capReached).toBe(true);
expect(mockCalls[0]).toMatchObject({ outcome: 'cap_reached', chargedCents: 0, inputTokens: 0, outputTokens: 0 });
});
test('admins are emailed once a month at 80%', async () => {
const at80 = hubStatus({ usedPercent: 81, usedCents: 4050 });
mockPost.mockResolvedValueOnce(hubStatus()).mockResolvedValue({ output: 'x', chargedCents: 1, status: at80 });
await runHelper('draft_message', 'u1', req);
await runHelper('draft_message', 'u1', req);
expect(mockMail).toHaveBeenCalledTimes(1);
expect(mockMail.mock.calls[0]).toEqual([expect.objectContaining({ to: 'admin@test.local', subject: 'AI allowance 81% used' })]);
const text = (mockMail.mock.calls[0] as unknown as [{ text: string }])[0].text;
expect(text).toContain('40K input and 9K output tokens');
expect(text).not.toMatch(/R\d/);
});
});
describe('Hub errors', () => {
test.each([
['AI_REFUSED', 'UNAVAILABLE', 'refused'],
['AI_INCOMPLETE', 'UNAVAILABLE', 'incomplete'],
['AI_OFF', 'FORBIDDEN', 'unavailable'],
['HUB_UNREACHABLE', 'UNAVAILABLE', 'unavailable'],
])('%s → %s, logged as %s', (hubCode, code, outcome) => {
const r = _internal.fromHubError({ code: hubCode, message: 'x' });
expect(r.error.code).toBe(code);
expect(r.outcome).toBe(outcome);
});
test('today starts at midnight South African time', () => {
expect(_internal.startOfToday(new Date('2026-11-10T22:30:00Z')).toISOString()).toBe('2026-11-10T22:00:00.000Z');
expect(_internal.startOfToday(new Date('2026-11-10T10:00:00Z')).toISOString()).toBe('2026-11-09T22:00:00.000Z');
});
});