Files
accounted/app/api/events/__tests__/route.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

429 lines
15 KiB
TypeScript

import { describe, it, expect, vi, beforeEach } from 'vitest'
import { NextResponse } from 'next/server'
import {
createMockRequest,
parseJsonResponse,
createQueuedMockSupabase,
} from '@/tests/helpers'
// Mock session auth (requireAuth enforces MFA; returns the request-scoped client)
const { supabase: mockSupabase, enqueue, reset } = createQueuedMockSupabase()
const requireAuthMock = vi.fn()
vi.mock('@/lib/auth/require-auth', () => ({
requireAuth: (...args: unknown[]) => requireAuthMock(...args),
}))
vi.mock('@/lib/company/context', () => ({
requireCompanyId: vi.fn().mockResolvedValue('company-1'),
getActiveCompanyId: vi.fn().mockResolvedValue('company-1'),
}))
// Mock API key auth. Only the three IO-bound helpers are faked: hasScope and
// DEFAULT_SCOPES stay real so the scope tests exercise the actual scope table.
const mockValidateApiKey = vi.fn()
const mockExtractBearerToken = vi.fn()
const mockCreateServiceClientNoCookies = vi.fn()
vi.mock('@/lib/auth/api-keys', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/lib/auth/api-keys')>()
return {
...actual,
validateApiKey: (...args: unknown[]) => mockValidateApiKey(...args),
extractBearerToken: (...args: unknown[]) => mockExtractBearerToken(...args),
createServiceClientNoCookies: () => mockCreateServiceClientNoCookies(),
}
})
import { DEFAULT_SCOPES } from '@/lib/auth/api-keys'
import { GET } from '../route'
interface ErrorEnvelope {
error: { code: string; message: string; message_en?: string; details?: unknown }
}
describe('GET /api/events', () => {
const mockUser = { id: 'user-1', email: 'test@test.se' }
const sampleEvents = [
{
sequence: 1,
event_type: 'invoice.created',
entity_id: 'inv-1',
data: { invoice: { id: 'inv-1', total: 1000 } },
created_at: '2026-03-25T10:00:00Z',
},
{
sequence: 2,
event_type: 'customer.created',
entity_id: 'cust-1',
data: { customer: { id: 'cust-1', name: 'Acme AB' } },
created_at: '2026-03-25T10:01:00Z',
},
]
/** A successful validateApiKey result, scoped and live by default. */
const apiKeyAuth = (overrides: Record<string, unknown> = {}) => ({
userId: 'user-1',
companyId: 'company-1',
apiKeyId: 'key-1',
apiKeyName: 'n8n poller',
scopes: ['events:read'],
mode: 'live',
...overrides,
})
/**
* Wire the service-role client the API-key branch uses. The route makes at
* most two queries in order: company_members, then event_log.
*/
const withKeyClient = (
results: { data?: unknown; error?: unknown }[],
) => {
const keyClient = createQueuedMockSupabase()
for (const r of results) keyClient.enqueue(r)
mockCreateServiceClientNoCookies.mockReturnValue(keyClient.supabase)
return keyClient
}
/** The membership row the re-check expects to find. */
const membershipFound = { data: { company_id: 'company-1' } }
beforeEach(() => {
vi.clearAllMocks()
reset()
mockExtractBearerToken.mockReturnValue(null)
requireAuthMock.mockResolvedValue({ user: mockUser, supabase: mockSupabase, error: null })
})
// ── Session auth (unchanged behaviour) ───────────────────────
it('returns 401 when not authenticated', async () => {
mockExtractBearerToken.mockReturnValue(null)
requireAuthMock.mockResolvedValue({
user: null,
supabase: mockSupabase,
error: NextResponse.json({ error: 'Unauthorized' }, { status: 401 }),
})
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse(response)
expect(status).toBe(401)
expect(body).toEqual({ error: 'Unauthorized' })
})
it('returns events with session auth', async () => {
// Exactly ONE queued result: if the session path wrongly ran the
// company_members re-check it would consume this and return no events.
enqueue({ data: sampleEvents })
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<{
data: typeof sampleEvents
cursor: number
has_more: boolean
}>(response)
expect(status).toBe(200)
expect(body.data).toHaveLength(2)
expect(body.cursor).toBe(2)
expect(body.has_more).toBe(false)
expect(mockValidateApiKey).not.toHaveBeenCalled()
expect(response.headers.get('X-Gnubok-Mode')).toBeNull()
})
// ── API key auth ─────────────────────────────────────────────
it('returns events with API key auth', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_test123')
mockValidateApiKey.mockResolvedValue(apiKeyAuth())
withKeyClient([membershipFound, { data: sampleEvents }])
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<{
data: typeof sampleEvents
}>(response)
expect(status).toBe(200)
expect(body.data).toHaveLength(2)
expect(mockValidateApiKey).toHaveBeenCalledWith('gnubok_sk_test123')
})
it('returns 401 for invalid API key', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_invalid')
mockValidateApiKey.mockResolvedValue({ error: 'Invalid API key', status: 401 })
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<ErrorEnvelope>(response)
expect(status).toBe(401)
expect(body.error.code).toBe('UNAUTHORIZED')
})
it('returns 429 with a RATE_LIMITED code for a rate-limited API key', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_limited')
mockValidateApiKey.mockResolvedValue({ error: 'Rate limit exceeded', status: 429 })
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<ErrorEnvelope>(response)
expect(status).toBe(429)
expect(body.error.code).toBe('RATE_LIMITED')
})
// ── Guard 1: scope ───────────────────────────────────────────
it('returns 403 INSUFFICIENT_SCOPE for a key without events:read', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_noscope')
mockValidateApiKey.mockResolvedValue(
apiKeyAuth({ scopes: ['reports:read', 'invoices:read'] }),
)
const keyClient = withKeyClient([membershipFound, { data: sampleEvents }])
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<ErrorEnvelope>(response)
expect(status).toBe(403)
expect(body.error.code).toBe('INSUFFICIENT_SCOPE')
expect(body.error.details).toMatchObject({ required_scope: 'events:read' })
// Denied before any DB access.
expect(keyClient.supabase.from).not.toHaveBeenCalled()
})
it('returns 403 for a legacy null-scope key falling back to DEFAULT_SCOPES', async () => {
// validateApiKey substitutes DEFAULT_SCOPES when the api_keys row has
// scopes = NULL. Those six read scopes do NOT include events:read.
expect(DEFAULT_SCOPES).not.toContain('events:read')
mockExtractBearerToken.mockReturnValue('gnubok_sk_legacy')
mockValidateApiKey.mockResolvedValue(apiKeyAuth({ scopes: DEFAULT_SCOPES }))
withKeyClient([membershipFound, { data: sampleEvents }])
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<ErrorEnvelope>(response)
expect(status).toBe(403)
expect(body.error.code).toBe('INSUFFICIENT_SCOPE')
})
// ── Guard 2: company membership re-check ─────────────────────
it('returns 404 when the key user is no longer a member of the bound company', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_offboarded')
mockValidateApiKey.mockResolvedValue(apiKeyAuth())
// Membership lookup finds nothing (offboarded, or company archived).
withKeyClient([{ data: null }, { data: sampleEvents }])
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<ErrorEnvelope>(response)
expect(status).toBe(404)
expect(body.error.code).toBe('NOT_FOUND')
})
it('returns 500 when the membership lookup itself fails', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_dberror')
mockValidateApiKey.mockResolvedValue(apiKeyAuth())
withKeyClient([{ error: { message: 'connection failure' } }, { data: sampleEvents }])
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<ErrorEnvelope>(response)
expect(status).toBe(500)
expect(body.error.code).toBe('INTERNAL_ERROR')
})
// ── Guard 3: test-mode keys ──────────────────────────────────
it('serves a test-mode key and labels the response X-Gnubok-Mode: test', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_test_abc')
mockValidateApiKey.mockResolvedValue(apiKeyAuth({ mode: 'test' }))
withKeyClient([membershipFound, { data: sampleEvents }])
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<{ data: typeof sampleEvents }>(response)
// A read has no write path to simulate, so it is served (matching every v1
// read) rather than blocked with TEST_KEY_WRITE_BLOCKED.
expect(status).toBe(200)
expect(body.data).toHaveLength(2)
expect(response.headers.get('X-Gnubok-Mode')).toBe('test')
})
it('does not label live-key responses with X-Gnubok-Mode', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_live')
mockValidateApiKey.mockResolvedValue(apiKeyAuth({ mode: 'live' }))
withKeyClient([membershipFound, { data: sampleEvents }])
const request = createMockRequest('/api/events')
const response = await GET(request)
expect(response.headers.get('X-Gnubok-Mode')).toBeNull()
})
// ── Payload minimisation ─────────────────────────────────────
it('minimises event payloads before returning them', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_ok')
mockValidateApiKey.mockResolvedValue(apiKeyAuth())
withKeyClient([
membershipFound,
{
data: [
{
sequence: 7,
event_type: 'invoice.created',
entity_id: 'inv-7',
// userId is what minimisePayload strips: an internal
// auth.users.id that identifies the gnubok-side actor.
data: { userId: 'user-1', invoice: { id: 'inv-7', total: 1250 } },
created_at: '2026-03-25T10:00:00Z',
},
],
},
])
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<{
data: { data: Record<string, unknown> }[]
}>(response)
expect(status).toBe(200)
expect(body.data[0].data).not.toHaveProperty('userId')
expect(body.data[0].data).toHaveProperty('invoice')
})
it('leaves non-object payloads untouched', async () => {
enqueue({
data: [
{
sequence: 3,
event_type: 'period.locked',
entity_id: null,
data: null,
created_at: '2026-03-25T10:00:00Z',
},
],
})
const request = createMockRequest('/api/events')
const response = await GET(request)
const { status, body } = await parseJsonResponse<{ data: { data: unknown }[] }>(response)
expect(status).toBe(200)
expect(body.data[0].data).toBeNull()
})
// ── Query params + cursor semantics ──────────────────────────
it('supports after cursor parameter', async () => {
enqueue({ data: [sampleEvents[1]] })
const request = createMockRequest('/api/events', {
searchParams: { after: '1' },
})
const response = await GET(request)
const { status, body } = await parseJsonResponse<{
data: typeof sampleEvents
cursor: number
}>(response)
expect(status).toBe(200)
expect(body.data).toHaveLength(1)
expect(body.cursor).toBe(2)
})
it('supports types filter parameter', async () => {
enqueue({ data: [sampleEvents[0]] })
const request = createMockRequest('/api/events', {
searchParams: { types: 'invoice.created' },
})
const response = await GET(request)
const { status, body } = await parseJsonResponse<{
data: typeof sampleEvents
}>(response)
expect(status).toBe(200)
expect(body.data).toHaveLength(1)
})
it('returns has_more=true when results equal limit', async () => {
// Return exactly `limit` items to trigger has_more
const events = Array.from({ length: 2 }, (_, i) => ({
sequence: i + 1,
event_type: 'invoice.created',
entity_id: `inv-${i}`,
data: {},
created_at: '2026-03-25T10:00:00Z',
}))
enqueue({ data: events })
const request = createMockRequest('/api/events', {
searchParams: { limit: '2' },
})
const response = await GET(request)
const { body } = await parseJsonResponse<{ has_more: boolean }>(response)
expect(body.has_more).toBe(true)
})
it('returns cursor=0 when no events and no after param', async () => {
enqueue({ data: [] })
const request = createMockRequest('/api/events')
const response = await GET(request)
const { body } = await parseJsonResponse<{ cursor: number; data: unknown[] }>(response)
expect(body.data).toHaveLength(0)
expect(body.cursor).toBe(0)
})
it('returns cursor=after when no events but after param provided', async () => {
enqueue({ data: [] })
const request = createMockRequest('/api/events', {
searchParams: { after: '42' },
})
const response = await GET(request)
const { body } = await parseJsonResponse<{ cursor: number }>(response)
expect(body.cursor).toBe(42)
})
it('rejects invalid limit parameter', async () => {
const request = createMockRequest('/api/events', {
searchParams: { limit: '999' },
})
const response = await GET(request)
const { status } = await parseJsonResponse(response)
expect(status).toBe(400)
})
it('rejects invalid query params before running the event query for API keys', async () => {
mockExtractBearerToken.mockReturnValue('gnubok_sk_ok')
mockValidateApiKey.mockResolvedValue(apiKeyAuth())
withKeyClient([membershipFound, { data: sampleEvents }])
const request = createMockRequest('/api/events', {
searchParams: { after: '-1' },
})
const response = await GET(request)
const { status } = await parseJsonResponse(response)
expect(status).toBe(400)
})
})