Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
10.3 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { type Server, createServer } from 'node:http'
import { type AddressInfo } from 'node:net'
import request from 'supertest'
import { createApp } from '../src/app.js'
import { config } from '../src/config.js'
import { setupInvitationPasswordWithToken } from '../src/services/invitationPasswordService.js'

const recoveryProof = 'synthetic-one-use-recovery-proof'

describe('password reset preview authority failures', () => {
  let previousControlApiBaseUrl: string
  let previousControlApiServiceToken: string
  let upstream: Server | undefined

  beforeEach(() => {
    previousControlApiBaseUrl = config.controlApiBaseUrl
    previousControlApiServiceToken = config.controlApiServiceToken
    config.controlApiServiceToken = 'synthetic-internal-service-token'
  })

  afterEach(async () => {
    config.controlApiBaseUrl = previousControlApiBaseUrl
    config.controlApiServiceToken = previousControlApiServiceToken
    vi.unstubAllGlobals()
    if (upstream?.listening) {
      await new Promise<void>((resolve, reject) =>
        upstream!.close(error => (error ? reject(error) : resolve()))
      )
    }
    upstream = undefined
  })

  async function startUpstream(handler: Parameters<typeof createServer>[0]): Promise<void> {
    upstream = createServer(handler)
    await new Promise<void>((resolve, reject) => {
      upstream!.once('error', reject)
      upstream!.listen(0, '127.0.0.1', resolve)
    })
    const address = upstream.address() as AddressInfo
    config.controlApiBaseUrl = `http://127.0.0.1:${address.port}/api/v1`
  }

  async function submitReset() {
    return request(createApp()).post('/api/v1/invitations/password').send({
      token: recoveryProof,
      email: '[email protected]',
      invitationId: '00000000-0000-4000-8000-000000000001',
      password: 'Synthetic-Replacement-Password-123',
    })
  }

  async function submitDedicatedReset() {
    return request(createApp()).post('/api/v1/invitations/password-reset').send({
      token: recoveryProof,
      email: '[email protected]',
      invitationId: '00000000-0000-4000-8000-000000000001',
      password: 'Synthetic-Replacement-Password-123',
    })
  }

  async function lookupInvitation() {
    return request(createApp()).get(`/api/v1/invitations/token/${recoveryProof}`)
  }

  it('sanitizes a non-JSON preview failure before any one-use reset POST', async () => {
    let previewRequests = 0
    let resetPosts = 0
    let requestedPath = ''
    await startUpstream((req, res) => {
      if (req.method === 'POST') resetPosts += 1
      previewRequests += 1
      requestedPath = req.url || ''
      res.writeHead(502, { 'content-type': 'text/html' })
      res.end('<html>gateway unavailable</html>')
    })

    const response = await submitReset()

    expect(response.text).not.toContain(recoveryProof)
    expect(JSON.stringify(response.body)).not.toContain(recoveryProof)
    expect(response.status).toBe(503)
    expect(response.body).toEqual({ error: 'authority_unavailable', retryAfterSeconds: 2 })
    expect(response.headers['retry-after']).toBe('2')
    expect(response.headers['cache-control']).toContain('no-store')
    expect(requestedPath).toContain(encodeURIComponent(recoveryProof))
    expect(previewRequests).toBe(1)
    expect(resetPosts).toBe(0)
  })

  it('sanitizes a rejected preview transport and never submits the one-use reset POST', async () => {
    let previewRequests = 0
    let resetPosts = 0
    await startUpstream((req, res) => {
      if (req.method === 'POST') resetPosts += 1
      previewRequests += 1
      req.socket.destroy()
      res.destroy()
    })

    const response = await submitReset()

    expect(response.text).not.toContain(recoveryProof)
    expect(JSON.stringify(response.body)).not.toContain(recoveryProof)
    expect(response.status).toBe(503)
    expect(response.body).toEqual({ error: 'authority_unavailable', retryAfterSeconds: 2 })
    expect(response.headers['retry-after']).toBe('2')
    expect(previewRequests).toBe(1)
    expect(resetPosts).toBe(0)
  })

  it('sanitizes failures from the public invitation-preview route too', async () => {
    let requestedPath = ''
    await startUpstream((req, res) => {
      requestedPath = req.url || ''
      res.writeHead(502, { 'content-type': 'text/html' })
      res.end('<html>gateway unavailable</html>')
    })

    const response = await lookupInvitation()

    expect(response.text).not.toContain(recoveryProof)
    expect(JSON.stringify(response.body)).not.toContain(recoveryProof)
    expect(response.status).toBe(503)
    expect(response.body).toEqual({ error: 'authority_unavailable', retryAfterSeconds: 2 })
    expect(response.headers['retry-after']).toBe('2')
    expect(requestedPath).toContain(encodeURIComponent(recoveryProof))
  })

  it('keeps a reset dispatch failure unknown and never retries the one-use proof', async () => {
    const fetchMock = vi
      .fn()
      .mockRejectedValue(new TypeError('private producer URL and signed proof'))
    vi.stubGlobal('fetch', fetchMock)
    config.controlApiBaseUrl = 'http://control-api.example.invalid/api/v1'

    const response = await submitDedicatedReset()

    expect(response.status).toBe(503)
    expect(response.body).toEqual({ error: 'recovery_outcome_unknown', retryAfterSeconds: 2 })
    expect(response.headers['retry-after']).toBe('2')
    expect(response.headers['set-cookie']).toBeUndefined()
    expect(response.text).not.toContain('private producer URL')
    expect(response.text).not.toContain(recoveryProof)
    expect(fetchMock).toHaveBeenCalledTimes(1)
  })

  it('keeps an unread reset response unknown without replaying the mutation', async () => {
    const fetchMock = vi.fn().mockResolvedValue({
      ok: true,
      status: 200,
      text: vi.fn().mockRejectedValue(new Error('private response proof')),
    })
    vi.stubGlobal('fetch', fetchMock)
    config.controlApiBaseUrl = 'http://control-api.example.invalid/api/v1'

    const response = await submitDedicatedReset()

    expect(response.status).toBe(503)
    expect(response.body).toEqual({ error: 'recovery_outcome_unknown', retryAfterSeconds: 2 })
    expect(response.headers['retry-after']).toBe('2')
    expect(response.headers['set-cookie']).toBeUndefined()
    expect(response.text).not.toContain('private response proof')
    expect(response.text).not.toContain(recoveryProof)
    expect(fetchMock).toHaveBeenCalledTimes(1)
  })

  it('preserves a definite internal callback failure without retry or proof replay', async () => {
    let resetPosts = 0
    await startUpstream((req, res) => {
      if (req.method === 'POST') resetPosts += 1
      res.writeHead(500, {
        'content-type': 'application/json',
        'retry-after': '1200',
        'x-ratelimit-remaining': '0',
      })
      res.end(JSON.stringify({ error: 'internal_error', detail: 'private reset diagnostic' }))
    })

    const response = await submitDedicatedReset()

    expect(response.status).toBe(500)
    expect(response.body).toEqual({ error: 'internal_error' })
    expect(response.headers['retry-after']).toBeUndefined()
    expect(response.headers['x-ratelimit-remaining']).toBeUndefined()
    expect(response.headers['cache-control']).toContain('no-store')
    expect(response.headers['set-cookie']).toBeUndefined()
    expect(response.text).not.toContain('private reset diagnostic')
    expect(response.text).not.toContain(recoveryProof)
    expect(resetPosts).toBe(1)
  })

  it('sanitizes an unrecognized producer client response without a retry hint', async () => {
    await startUpstream((_req, res) => {
      res.writeHead(400, { 'content-type': 'application/json' })
      res.end(JSON.stringify({ error: 'invalid payload', detail: 'private producer data' }))
    })

    const response = await submitDedicatedReset()

    expect(response.status).toBe(502)
    expect(response.body).toEqual({
      error: 'Password recovery service returned an invalid response',
    })
    expect(response.headers['retry-after']).toBeUndefined()
    expect(response.headers['set-cookie']).toBeUndefined()
    expect(response.text).not.toContain('private producer data')
    expect(response.text).not.toContain(recoveryProof)
  })

  it('returns a sanitized nonretryable error when request construction fails before dispatch', async () => {
    const fetchMock = vi.fn()
    vi.stubGlobal('fetch', fetchMock)
    config.controlApiBaseUrl = 'not a valid URL'

    const response = await submitDedicatedReset()

    expect(response.status).toBe(500)
    expect(response.body).toEqual({ error: 'Internal Server Error' })
    expect(response.headers['retry-after']).toBeUndefined()
    expect(response.headers['set-cookie']).toBeUndefined()
    expect(response.text).not.toContain('not a valid URL')
    expect(response.text).not.toContain(recoveryProof)
    expect(fetchMock).not.toHaveBeenCalled()
  })
})

const fetchMock = vi.fn()

describe('setupInvitationPasswordWithToken', () => {
  beforeEach(() => {
    fetchMock.mockReset()
    vi.stubGlobal('fetch', fetchMock)
  })

  afterEach(() => vi.unstubAllGlobals())

  it('preserves invalid recovery proof as a safe link error', async () => {
    fetchMock.mockResolvedValue(
      new Response(JSON.stringify({ error: 'invalid_invitation' }), { status: 400 })
    )

    await expect(
      setupInvitationPasswordWithToken(
        'synthetic-proof',
        '[email protected]',
        'synthetic-row-id',
        'synthetic-password'
      )
    ).resolves.toEqual({ error: 'invalid_invitation' })
  })

  it('continues to identify password-policy rejections as invalid passwords', async () => {
    fetchMock.mockResolvedValue(
      new Response(JSON.stringify({ error: 'invalid_password' }), { status: 400 })
    )

    await expect(
      setupInvitationPasswordWithToken(
        'synthetic-proof',
        '[email protected]',
        'synthetic-row-id',
        'short'
      )
    ).resolves.toEqual({ error: 'invalid_password' })
  })

  it('rejects an unrecognized producer error instead of treating it as a password error', async () => {
    fetchMock.mockResolvedValue(
      new Response(JSON.stringify({ error: 'invalid payload' }), { status: 400 })
    )

    await expect(
      setupInvitationPasswordWithToken(
        'synthetic-proof',
        '[email protected]',
        'synthetic-row-id',
        'Synthetic-Valid-Password-123'
      )
    ).rejects.toMatchObject({ name: 'ControlApiUnexpectedResponseError' })
  })
})