supabase__supabase/apps/studio/lib/api/apiWrappers.test.ts

import * as Sentry from '@sentry/nextjs'
import type { JwtPayload } from '@supabase/supabase-js'
import type { NextApiRequest, NextApiResponse } from 'next'
import { describe, expect, it, vi } from 'vitest'

import { apiAuthenticate } from './apiAuthenticate'
import { apiWrapper } from './apiWrapper'
import { ResponseError } from '@/types'

vi.mock('@/lib/constants', () => ({
  IS_PLATFORM: true,
  API_URL: 'https://api.example.com',
}))

vi.mock('./apiAuthenticate', () => ({
  apiAuthenticate: vi.fn(),
}))

vi.mock('@sentry/nextjs', () => ({
  captureException: vi.fn(),
}))

describe('apiWrapper', () => {
  const mockReq = {} as NextApiRequest
  const mockRes = {
    status: vi.fn().mockReturnThis(),
    json: vi.fn().mockReturnThis(),
  } as unknown as NextApiResponse
  const mockHandler = vi.fn()

  it('should call handler directly when withAuth is false', async () => {
    await apiWrapper(mockReq, mockRes, mockHandler, { withAuth: false })
    expect(mockHandler).toHaveBeenCalledWith(mockReq, mockRes, undefined)
    expect(apiAuthenticate).not.toHaveBeenCalled()
  })

  it('should pass JWT claims to handler when withAuth is true', async () => {
    const mockClaims: JwtPayload = {
      iss: 'supabase',
      sub: 'user-123',
      aud: 'authenticated',
      exp: 9999999999,
      iat: 1000000000,
      role: 'authenticated',
      aal: 'aal1',
      session_id: 'session-123',
    }
    vi.mocked(apiAuthenticate).mockResolvedValue(mockClaims)

    await apiWrapper(mockReq, mockRes, mockHandler, { withAuth: true })
    expect(apiAuthenticate).toHaveBeenCalledWith(mockReq, mockRes)
    expect(mockHandler).toHaveBeenCalledWith(mockReq, mockRes, mockClaims)
  })

  it('should return 401 when authentication fails', async () => {
    const mockError = { error: new ResponseError('Invalid token') }
    vi.mocked(apiAuthenticate).mockResolvedValue(mockError)

    await apiWrapper(mockReq, mockRes, mockHandler, { withAuth: true })
    expect(mockRes.status).toHaveBeenCalledWith(401)
    expect(mockHandler).not.toHaveBeenCalled()
  })

  it('should report to Sentry and return 500 when the handler throws', async () => {
    const mockError = new Error('boom')
    mockHandler.mockRejectedValue(mockError)

    await apiWrapper(mockReq, mockRes, mockHandler, { withAuth: false })
    expect(Sentry.captureException).toHaveBeenCalledWith(mockError)
    expect(mockRes.status).toHaveBeenCalledWith(500)
    expect(mockRes.json).toHaveBeenCalledWith({ error: mockError })
  })
})