import { beforeEach, describe, expect, test, vi } from 'vitest'; // Set a deterministic secret before anything reads it so that real crypto/jwt // helpers used by the route and by the test produce matching tokens. process.env.APP_SECRET = 'route-send-test-secret'; import { isbot } from 'isbot'; import clickhouse from '@/lib/clickhouse'; import { CACHE_TOKEN_TYPE, EVENT_TYPE } from '@/lib/constants'; import { getSalt, secret, uuid } from '@/lib/crypto'; import { getClientInfo, hasBlockedIp } from '@/lib/detect'; import { createToken, parseToken } from '@/lib/jwt'; import { fetchWebsite } from '@/lib/load'; import { parseRequest } from '@/lib/request'; import { createSession, saveEvent, saveSessionData, saveSessionLink, updateSession, } from '@/queries/sql'; import { POST } from './route'; vi.mock('@/lib/clickhouse', () => ({ default: { enabled: false } })); vi.mock('@/lib/detect', () => ({ getClientInfo: vi.fn(), hasBlockedIp: vi.fn(), })); vi.mock('@/lib/load', () => ({ fetchWebsite: vi.fn(), })); vi.mock('@/lib/request', () => ({ parseRequest: vi.fn(), })); vi.mock('@/queries/sql', () => ({ createSession: vi.fn(), saveEvent: vi.fn(), saveSessionData: vi.fn(), saveSessionLink: vi.fn(), updateSession: vi.fn(), })); vi.mock('isbot', () => ({ isbot: vi.fn(), })); const parseRequestMock = vi.mocked(parseRequest); const getClientInfoMock = vi.mocked(getClientInfo); const hasBlockedIpMock = vi.mocked(hasBlockedIp); const fetchWebsiteMock = vi.mocked(fetchWebsite); const isbotMock = vi.mocked(isbot); const createSessionMock = vi.mocked(createSession); const saveEventMock = vi.mocked(saveEvent); const saveSessionDataMock = vi.mocked(saveSessionData); const saveSessionLinkMock = vi.mocked(saveSessionLink); const updateSessionMock = vi.mocked(updateSession); const WEBSITE_ID = '11111111-1111-4111-8111-111111111111'; const LINK_ID = '22222222-2222-4222-8222-222222222222'; const PIXEL_ID = '33333333-3333-4333-8333-333333333333'; const defaultClientInfo = { ip: '203.0.113.5', userAgent: 'Mozilla/5.0', device: 'desktop', browser: 'chrome', os: 'Windows 10', country: 'US', region: 'US-CA', city: 'San Francisco', }; /** * Drives POST by making parseRequest resolve to the given body. Because the * route calls parseRequest(request, schema, ...), the schema is still captured * on the mock for direct schema assertions. */ function callPOST( { type, payload }: { type: string; payload: Record }, { headers }: { headers?: Record } = {}, ) { parseRequestMock.mockResolvedValue({ body: { type, payload }, error: undefined }); return POST( new Request('http://localhost/api/send', { method: 'POST', headers, }), ); } function makeComputedSessionId(sourceId: string, timestamp = 1704067200) { const createdAt = new Date(timestamp * 1000); const sessionSalt = getSalt(process.env.SALT_ROTATION || 'month', createdAt); return uuid(sourceId, defaultClientInfo.ip, defaultClientInfo.userAgent, sessionSalt); } beforeEach(() => { vi.clearAllMocks(); (clickhouse as any).enabled = false; delete process.env.DISABLE_BOT_CHECK; delete process.env.REMOVE_TRAILING_SLASH; delete process.env.SALT_ROTATION; isbotMock.mockReturnValue(false); hasBlockedIpMock.mockReturnValue(false); fetchWebsiteMock.mockResolvedValue({ id: WEBSITE_ID } as any); getClientInfoMock.mockResolvedValue({ ...defaultClientInfo } as any); createSessionMock.mockResolvedValue(undefined as any); saveEventMock.mockResolvedValue(undefined as any); saveSessionDataMock.mockResolvedValue(undefined as any); saveSessionLinkMock.mockResolvedValue(undefined as any); updateSessionMock.mockResolvedValue(undefined as any); }); describe('parseRequest error handling', () => { test('returns the parseRequest error response and does not process the event', async () => { parseRequestMock.mockResolvedValue({ body: undefined, error: () => Response.json({ error: { code: 'bad-request', status: 400 } }, { status: 400 }), }); const response = await POST(new Request('http://localhost/api/send', { method: 'POST' })); expect(response.status).toBe(400); expect(saveEventMock).not.toHaveBeenCalled(); expect(getClientInfoMock).not.toHaveBeenCalled(); }); test('calls parseRequest with skipAuth so tracker requests are unauthenticated', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' } }); expect(parseRequestMock.mock.calls[0][2]).toEqual({ skipAuth: true }); }); }); describe('schema validation', () => { // The schema is passed to parseRequest; grab it and exercise safeParse directly. async function getSchema() { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' } }); return parseRequestMock.mock.calls[0][1] as { safeParse: (value: unknown) => { success: boolean }; }; } test('rejects an invalid type enum value', async () => { const schema = await getSchema(); expect(schema.safeParse({ type: 'bogus', payload: { website: WEBSITE_ID } }).success).toBe( false, ); expect(schema.safeParse({ type: 'event', payload: { website: WEBSITE_ID } }).success).toBe( true, ); expect(schema.safeParse({ type: 'identify', payload: { website: WEBSITE_ID } }).success).toBe( true, ); expect( schema.safeParse({ type: 'performance', payload: { website: WEBSITE_ID } }).success, ).toBe(true); }); test('requires exactly one of website, link, or pixel', async () => { const schema = await getSchema(); // zero set -> invalid expect(schema.safeParse({ type: 'event', payload: {} }).success).toBe(false); // one set -> valid expect(schema.safeParse({ type: 'event', payload: { website: WEBSITE_ID } }).success).toBe( true, ); expect(schema.safeParse({ type: 'event', payload: { link: LINK_ID } }).success).toBe(true); expect(schema.safeParse({ type: 'event', payload: { pixel: PIXEL_ID } }).success).toBe(true); // two set -> invalid expect( schema.safeParse({ type: 'event', payload: { website: WEBSITE_ID, link: LINK_ID } }).success, ).toBe(false); // all three set -> invalid expect( schema.safeParse({ type: 'event', payload: { website: WEBSITE_ID, link: LINK_ID, pixel: PIXEL_ID }, }).success, ).toBe(false); }); test('rejects CSV formula injection triggers in name and tag', async () => { const schema = await getSchema(); for (const bad of ['=1+1', '+cmd', '-2', '@SUM', '\tvalue', '\rvalue']) { expect( schema.safeParse({ type: 'event', payload: { website: WEBSITE_ID, name: bad } }).success, ).toBe(false); expect( schema.safeParse({ type: 'event', payload: { website: WEBSITE_ID, tag: bad } }).success, ).toBe(false); } // A safe leading character passes. expect( schema.safeParse({ type: 'event', payload: { website: WEBSITE_ID, name: 'signup' } }).success, ).toBe(true); }); test('enforces web vitals numeric bounds', async () => { const schema = await getSchema(); expect( schema.safeParse({ type: 'performance', payload: { website: WEBSITE_ID, lcp: -1 } }).success, ).toBe(false); expect( schema.safeParse({ type: 'performance', payload: { website: WEBSITE_ID, lcp: 60001 } }) .success, ).toBe(false); expect( schema.safeParse({ type: 'performance', payload: { website: WEBSITE_ID, cls: 101 } }).success, ).toBe(false); expect( schema.safeParse({ type: 'performance', payload: { website: WEBSITE_ID, lcp: 2500 } }) .success, ).toBe(true); }); }); describe('bot detection gate', () => { test('returns a 200 no-op response for bots and skips persistence', async () => { isbotMock.mockReturnValue(true); const response = await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' }, }); expect(response.status).toBe(200); await expect(response.json()).resolves.toEqual({ beep: 'boop' }); expect(saveEventMock).not.toHaveBeenCalled(); }); test('DISABLE_BOT_CHECK bypasses the bot gate', async () => { process.env.DISABLE_BOT_CHECK = '1'; isbotMock.mockReturnValue(true); const response = await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' }, }); expect(response.status).toBe(200); await expect(response.json()).resolves.not.toEqual({ beep: 'boop' }); expect(saveEventMock).toHaveBeenCalledTimes(1); expect(isbotMock).not.toHaveBeenCalled(); }); }); describe('IP blocklist', () => { test('returns 403 when the client IP is blocked', async () => { hasBlockedIpMock.mockReturnValue(true); const response = await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' }, }); expect(response.status).toBe(403); await expect(response.json()).resolves.toMatchObject({ error: { code: 'forbidden', status: 403 }, }); expect(saveEventMock).not.toHaveBeenCalled(); }); }); describe('website lookup', () => { test('returns 400 when the website does not exist', async () => { fetchWebsiteMock.mockResolvedValue(null as any); const response = await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' }, }); expect(response.status).toBe(400); await expect(response.json()).resolves.toMatchObject({ error: { message: 'Website not found.', status: 400 }, }); expect(saveEventMock).not.toHaveBeenCalled(); }); test('does not look up a website for link events', async () => { await callPOST({ type: 'event', payload: { link: LINK_ID, url: '/' } }); expect(fetchWebsiteMock).not.toHaveBeenCalled(); }); }); describe('session creation', () => { test('creates a session when clickhouse is disabled and there is no cache', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' } }); expect(createSessionMock).toHaveBeenCalledTimes(1); expect(createSessionMock.mock.calls[0][0]).toMatchObject({ websiteId: WEBSITE_ID, browser: 'chrome', os: 'Windows 10', device: 'desktop', }); }); test('does not create a session when clickhouse is enabled', async () => { (clickhouse as any).enabled = true; await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' } }); expect(createSessionMock).not.toHaveBeenCalled(); }); }); describe('eventType selection ladder', () => { test('link events use the linkEvent type', async () => { await callPOST({ type: 'event', payload: { link: LINK_ID, url: '/' } }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ eventType: EVENT_TYPE.linkEvent }); }); test('pixel events use the pixelEvent type', async () => { await callPOST({ type: 'event', payload: { pixel: PIXEL_ID, url: '/' } }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ eventType: EVENT_TYPE.pixelEvent }); }); test('named website events use the customEvent type', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/', name: 'signup' }, }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ eventType: EVENT_TYPE.customEvent, eventName: 'signup', }); }); test('unnamed website events use the pageView type', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' } }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ eventType: EVENT_TYPE.pageView }); }); }); describe('event url and referrer parsing', () => { test('extracts url path, query, domain and referrer fields', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/products?utm_source=news&gclid=abc', referrer: 'https://www.google.com/search?q=umami', }, }); const arg = saveEventMock.mock.calls[0][0] as Record; expect(arg).toMatchObject({ hostname: 'example.com', urlPath: '/products', urlQuery: 'utm_source=news&gclid=abc', utmSource: 'news', gclid: 'abc', referrerPath: '/search', referrerQuery: 'q=umami', referrerDomain: 'google.com', }); }); test('does not save referrer domain when it matches the hostname', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/products', referrer: 'https://www.example.com/prev?a=1', }, }); const arg = saveEventMock.mock.calls[0][0] as Record; expect(arg).toMatchObject({ referrerPath: '/prev', referrerQuery: 'a=1', }); expect(arg.referrerDomain).toBeUndefined(); }); test('does not save referrer domain for a path-only referrer', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/products', referrer: '/prev?a=1', }, }); const arg = saveEventMock.mock.calls[0][0] as Record; expect(arg).toMatchObject({ referrerPath: '/prev', referrerQuery: 'a=1', }); expect(arg.referrerDomain).toBeUndefined(); }); test('saves referrer domain for a lookalike domain that only shares a prefix', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/products', referrer: 'https://example.com.br/page', }, }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ referrerDomain: 'example.com.br', referrerPath: '/page', }); }); test('resolves a path-only referrer against the url domain when hostname is missing', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: 'https://example.com/products', referrer: '/prev', }, }); const arg = saveEventMock.mock.calls[0][0] as Record; expect(arg).toMatchObject({ referrerPath: '/prev' }); expect(arg.referrerDomain).toBeUndefined(); }); test('does not save referrer domain when hostname differs only by case', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'EXAMPLE.com', url: '/products', referrer: 'https://example.com/prev', }, }); const arg = saveEventMock.mock.calls[0][0] as Record; expect(arg).toMatchObject({ referrerPath: '/prev' }); expect(arg.referrerDomain).toBeUndefined(); }); test('does not save referrer domain when hostname includes a port', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com:8443', url: '/products', referrer: 'https://example.com:8443/prev', }, }); const arg = saveEventMock.mock.calls[0][0] as Record; expect(arg).toMatchObject({ referrerPath: '/prev' }); expect(arg.referrerDomain).toBeUndefined(); }); test('REMOVE_TRAILING_SLASH strips a trailing slash from the url path', async () => { process.env.REMOVE_TRAILING_SLASH = '1'; await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/blog/' }, }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ urlPath: '/blog' }); }); test('REMOVE_TRAILING_SLASH keeps the root path as "/"', async () => { process.env.REMOVE_TRAILING_SLASH = '1'; await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/' }, }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ urlPath: '/' }); }); test('REMOVE_TRAILING_SLASH keeps the root path when the url has a hash', async () => { process.env.REMOVE_TRAILING_SLASH = '1'; await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/#hero' }, }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ urlPath: '/#hero' }); }); test('REMOVE_TRAILING_SLASH strips a trailing slash before the hash', async () => { process.env.REMOVE_TRAILING_SLASH = '1'; await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/blog/#hero' }, }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ urlPath: '/blog#hero' }); }); test('maps a "/undefined" pathname to an empty url path', async () => { await callPOST({ type: 'event', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/undefined' }, }); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ urlPath: '' }); }); }); describe('cache token handling', () => { function makeCacheToken(overrides: Record = {}) { return createToken( { type: CACHE_TOKEN_TYPE, websiteId: WEBSITE_ID, sessionId: 'cached-session', visitId: 'cached-visit', iat: Math.floor(Date.now() / 1000), ...overrides, }, secret(), ); } test('a valid cache token skips website lookup and session creation when it matches the computed session', async () => { const timestamp = 1704067200; const token = makeCacheToken({ sessionId: makeComputedSessionId(WEBSITE_ID, timestamp) }); const response = await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/', timestamp } }, { headers: { 'x-umami-cache': token } }, ); expect(fetchWebsiteMock).not.toHaveBeenCalled(); expect(createSessionMock).not.toHaveBeenCalled(); await expect(response.json()).resolves.toMatchObject({ visitId: 'cached-visit' }); }); test('a valid cache token creates the computed session before event writes when the cached session differs', async () => { const token = makeCacheToken({ sessionId: 'cached-session' }); await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/' } }, { headers: { 'x-umami-cache': token } }, ); expect(createSessionMock).toHaveBeenCalledTimes(1); const createdSession = createSessionMock.mock.calls[0][0] as Record; const savedEvent = saveEventMock.mock.calls[0][0] as Record; expect(createdSession.id).not.toBe('cached-session'); expect(savedEvent.sessionId).toBe(createdSession.id); }); test('a valid cache token creates the computed session before identify writes when the cached session differs', async () => { const token = makeCacheToken({ sessionId: 'cached-session' }); await callPOST( { type: 'identify', payload: { website: WEBSITE_ID, id: 'user-42', data: { plan: 'pro' } } }, { headers: { 'x-umami-cache': token } }, ); expect(createSessionMock).toHaveBeenCalledTimes(1); const createdSession = createSessionMock.mock.calls[0][0] as Record; const savedLink = saveSessionLinkMock.mock.calls[0][0] as Record; const updatedSession = updateSessionMock.mock.calls[0][0] as Record; const savedSessionData = saveSessionDataMock.mock.calls[0][0] as Record; expect(createdSession.id).not.toBe('cached-session'); expect(savedLink.sessionId).toBe(createdSession.id); expect(updatedSession.sessionId).toBe(createdSession.id); expect(savedSessionData.sessionId).toBe(createdSession.id); }); test('an invalid cache token falls back to website lookup', async () => { await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/' } }, { headers: { 'x-umami-cache': 'not-a-jwt' } }, ); expect(fetchWebsiteMock).toHaveBeenCalledTimes(1); }); test('a token with a non-cache type is ignored', async () => { const token = createToken( { type: 'share', websiteId: WEBSITE_ID, sessionId: 's', visitId: 'v', iat: 1 }, secret(), ); await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/' } }, { headers: { 'x-umami-cache': token } }, ); expect(fetchWebsiteMock).toHaveBeenCalledTimes(1); expect(createSessionMock).toHaveBeenCalledTimes(1); }); test('an expired cache token is treated as absent', async () => { const token = createToken( { type: CACHE_TOKEN_TYPE, websiteId: WEBSITE_ID, sessionId: 'cached-session', visitId: 'cached-visit', }, secret(), { expiresIn: -10 }, ); const response = await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/' } }, { headers: { 'x-umami-cache': token } }, ); expect(fetchWebsiteMock).toHaveBeenCalledTimes(1); // A fresh visitId is generated rather than reusing the token's value. await expect(response.json()).resolves.not.toMatchObject({ visitId: 'cached-visit' }); }); test('returns a signed cache token that round-trips to the response identifiers', async () => { const response = await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' }, }); const body = (await response.json()) as Record; const decoded = parseToken(body.cache, secret()) as Record; expect(decoded.type).toBe(CACHE_TOKEN_TYPE); expect(decoded.sessionId).toBe(body.sessionId); expect(decoded.visitId).toBe(body.visitId); expect(decoded.websiteId).toBe(WEBSITE_ID); }); }); describe('30-minute visit expiry', () => { test('regenerates the visit when the cached iat is older than 30 minutes', async () => { const oldIat = Math.floor(Date.now() / 1000) - 2000; const token = createToken( { type: CACHE_TOKEN_TYPE, websiteId: WEBSITE_ID, sessionId: 'cached-session', visitId: 'cached-visit', iat: oldIat, }, secret(), ); const response = await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/' } }, { headers: { 'x-umami-cache': token } }, ); const body = (await response.json()) as Record; expect(body.visitId).not.toBe('cached-visit'); }); test('keeps the cached visit when within the 30-minute window', async () => { const recentIat = Math.floor(Date.now() / 1000) - 100; const token = createToken( { type: CACHE_TOKEN_TYPE, websiteId: WEBSITE_ID, sessionId: 'cached-session', visitId: 'cached-visit', iat: recentIat, }, secret(), ); const response = await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/' } }, { headers: { 'x-umami-cache': token } }, ); await expect(response.json()).resolves.toMatchObject({ visitId: 'cached-visit' }); }); test('does not expire the visit when an explicit timestamp is supplied', async () => { const oldIat = Math.floor(Date.now() / 1000) - 5000; const token = createToken( { type: CACHE_TOKEN_TYPE, websiteId: WEBSITE_ID, sessionId: 'cached-session', visitId: 'cached-visit', iat: oldIat, }, secret(), ); const response = await callPOST( { type: 'event', payload: { website: WEBSITE_ID, url: '/', timestamp: 1000000000 }, }, { headers: { 'x-umami-cache': token } }, ); await expect(response.json()).resolves.toMatchObject({ visitId: 'cached-visit' }); }); }); describe('identify collection', () => { test('saves a session link and updates the session for a new distinctId', async () => { await callPOST({ type: 'identify', payload: { website: WEBSITE_ID, id: 'user-42' }, }); expect(saveSessionLinkMock).toHaveBeenCalledTimes(1); expect(updateSessionMock).toHaveBeenCalledTimes(1); expect(saveSessionLinkMock.mock.calls[0][0]).toMatchObject({ websiteId: WEBSITE_ID, distinctId: 'user-42', }); }); test('saves session data when a data payload is present', async () => { await callPOST({ type: 'identify', payload: { website: WEBSITE_ID, id: 'user-42', data: { plan: 'pro' } }, }); expect(saveSessionDataMock).toHaveBeenCalledTimes(1); expect(saveSessionDataMock.mock.calls[0][0]).toMatchObject({ websiteId: WEBSITE_ID, sessionData: { plan: 'pro' }, }); }); test('skips identity writes when the cached sessionLinkId already matches', async () => { // First identify establishes the link and returns a cache token carrying // the resulting sessionLinkId. const first = await callPOST({ type: 'identify', payload: { website: WEBSITE_ID, id: 'user-42' }, }); const firstBody = (await first.json()) as Record; const token = firstBody.cache; saveSessionLinkMock.mockClear(); updateSessionMock.mockClear(); // Replaying with that token should recognise the same identity and skip. await callPOST( { type: 'identify', payload: { website: WEBSITE_ID, id: 'user-42' } }, { headers: { 'x-umami-cache': token } }, ); expect(saveSessionLinkMock).not.toHaveBeenCalled(); expect(updateSessionMock).not.toHaveBeenCalled(); }); test('does not write identity records without a website id', async () => { await callPOST({ type: 'identify', payload: { link: LINK_ID, id: 'user-42' }, }); expect(saveSessionLinkMock).not.toHaveBeenCalled(); expect(updateSessionMock).not.toHaveBeenCalled(); }); test('identity link failures do not block session data writes', async () => { const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {}); saveSessionLinkMock.mockRejectedValue(new Error('link failed')); const response = await callPOST({ type: 'identify', payload: { website: WEBSITE_ID, id: 'user-42', data: { plan: 'pro' } }, }); expect(response.status).toBe(200); expect(saveSessionDataMock).toHaveBeenCalledTimes(1); consoleError.mockRestore(); }); }); describe('performance collection', () => { test('saves a performance event with the web vitals metrics', async () => { await callPOST({ type: 'performance', payload: { website: WEBSITE_ID, hostname: 'example.com', url: '/dashboard', lcp: 1200, inp: 50, cls: 0.05, fcp: 900, ttfb: 300, }, }); expect(saveEventMock).toHaveBeenCalledTimes(1); expect(saveEventMock.mock.calls[0][0]).toMatchObject({ eventType: EVENT_TYPE.performance, urlPath: '/dashboard', lcp: 1200, inp: 50, cls: 0.05, fcp: 900, ttfb: 300, }); }); }); describe('error handling', () => { test('returns a 500 server error when persistence throws', async () => { saveEventMock.mockRejectedValue(new Error('db down')); const consoleLog = vi.spyOn(console, 'log').mockImplementation(() => {}); const response = await callPOST({ type: 'event', payload: { website: WEBSITE_ID, url: '/' }, }); expect(response.status).toBe(500); await expect(response.json()).resolves.toMatchObject({ error: { code: 'server-error', status: 500 }, }); consoleLog.mockRestore(); }); });