test.js

const assert = require('assert')
const http = require('http')
const { test, before, after } = require('node:test')
const { createSwitchboardServer } = require('./dist/index')

let server
let port

function negotiationItem(id, { forAddress = 'recipient-address', fromAddress = 'sender-address', networkId = 'network-a' } = {}) {
  return {
    id,
    for: forAddress,
    from: fromAddress,
    negotiation: {
      type: 'offer',
      address: fromAddress,
      networkId,
      connectionId: `connection-${id}`,
      sdp: 'v=0\r\ns=valid\r\n',
      timestamp: Date.now()
    }
  }
}

function switchboardRequest({ networkId = 'network-a', address = 'sender-address', negotiationItems = [], acknowledgedNegotiationIds = [] } = {}) {
  return { networkId, address, negotiationItems, acknowledgedNegotiationIds }
}

function request({ method = 'POST', path = '/', body = '', headers = {}, chunks } = {}) {
  return new Promise((resolve, reject) => {
    const payload = typeof body === 'string' ? body : JSON.stringify(body)
    const requestHeaders = { ...headers }
    if (method === 'POST' && !requestHeaders['Content-Length']) {
      requestHeaders['Content-Type'] = requestHeaders['Content-Type'] || 'application/json'
      requestHeaders['Content-Length'] = Buffer.byteLength(payload)
    }
    const req = http.request({ port, path, method, headers: requestHeaders }, res => {
      let response = ''
      res.on('data', chunk => response += chunk)
      res.on('end', () => resolve({
        status: res.statusCode,
        headers: res.headers,
        body: response ? JSON.parse(response) : undefined
      }))
    })
    req.on('error', reject)
    if (chunks) chunks.forEach(chunk => req.write(chunk))
    else req.write(payload)
    req.end()
  })
}

before(async () => {
  server = createSwitchboardServer()
  await new Promise(resolve => server.listen(0, resolve))
  port = server.address().port
})

after(async () => {
  await new Promise(resolve => server.close(resolve))
})

test('serves CORS preflight, health, and readiness endpoints', async () => {
  let response = await request({ method: 'OPTIONS' })
  assert.equal(response.status, 204)
  assert.match(response.headers['access-control-allow-methods'], /GET/)
  assert.ok(response.headers['x-request-id'])

  for (const path of ['/health', '/ready']) {
    response = await request({ method: 'GET', path })
    assert.equal(response.status, 200)
    assert.deepEqual(response.body, { status: 'ok' })
    assert.ok(response.headers['x-request-id'])
  }

  const missing = await request({ method: 'GET', path: '/' })
  assert.equal(missing.status, 404)
  assert.deepEqual(missing.body, { error: 'not found' })
})

test('rejects unsupported methods and malformed request bodies', async () => {
  let response = await request({ method: 'PUT' })
  assert.equal(response.status, 405)
  assert.deepEqual(response.body, { error: 'invalid request' })

  response = await request({ body: '{' })
  assert.equal(response.status, 400)

  response = await request({ body: switchboardRequest({ negotiationItems: {} }) })
  assert.equal(response.status, 400)

  response = await request({ body: { networkId: 'network-a', address: 'sender-address', negotiationItems: [] } })
  assert.equal(response.status, 400)
})

test('enforces streamed body limits', async () => {
  const oversized = 'x'.repeat(1024 * 1024 + 1)
  const response = await request({ body: oversized })
  assert.equal(response.status, 413)
  assert.deepEqual(response.body, { error: 'request too large' })
})

test('validates negotiation identity, identifiers, and acknowledgement IDs', async () => {
  const item = negotiationItem('validation-item')
  const invalidRequests = [
    switchboardRequest({ negotiationItems: [{ ...item, id: '' }] }),
    switchboardRequest({ negotiationItems: [{ ...item, from: 'forged-address' }] }),
    switchboardRequest({ negotiationItems: [negotiationItem('wrong-network', { networkId: 'other-network' })] }),
    switchboardRequest({ negotiationItems: [{ ...item, negotiation: { ...item.negotiation, address: 'forged-address' } }] }),
    switchboardRequest({ negotiationItems: [{ ...item, negotiation: { ...item.negotiation, sdp: 'x'.repeat(65537) } }] }),
    switchboardRequest({ acknowledgedNegotiationIds: [' invalid-id'] }),
    switchboardRequest({ acknowledgedNegotiationIds: new Array(101).fill('id') })
  ]

  for (const body of invalidRequests) {
    const response = await request({ body })
    assert.equal(response.status, 400)
    assert.deepEqual(response.body, { error: 'invalid request' })
  }
})

test('deduplicates IDs per network and only permits recipients to acknowledge', async () => {
  const item = negotiationItem('same-id')
  let response = await request({ body: switchboardRequest({ negotiationItems: [item] }) })
  assert.equal(response.status, 200)

  response = await request({ body: switchboardRequest({ negotiationItems: [item] }) })
  assert.equal(response.status, 200)

  response = await request({ body: switchboardRequest({ address: 'attacker-address', acknowledgedNegotiationIds: ['same-id'] }) })
  assert.equal(response.status, 200)

  response = await request({ body: switchboardRequest({ address: 'recipient-address' }) })
  assert.equal(response.status, 200)
  assert.deepEqual(response.body.negotiationItems.map(item => item.id), ['same-id'])

  response = await request({ body: switchboardRequest({ address: 'recipient-address', acknowledgedNegotiationIds: ['same-id'] }) })
  assert.equal(response.status, 200)
  assert.deepEqual(response.body.negotiationItems, [])

  const otherNetworkItem = negotiationItem('same-id', { networkId: 'network-b' })
  response = await request({ body: switchboardRequest({ networkId: 'network-b', negotiationItems: [otherNetworkItem] }) })
  assert.equal(response.status, 200)
  response = await request({ body: switchboardRequest({ networkId: 'network-b', address: 'recipient-address' }) })
  assert.deepEqual(response.body.negotiationItems.map(item => item.id), ['same-id'])
})

test('deduplicates concurrent retries and expires undelivered negotiations', async () => {
  const concurrentItem = negotiationItem('concurrent-id', { forAddress: 'concurrent-recipient' })
  await Promise.all(Array.from({ length: 10 }, () => request({ body: switchboardRequest({ negotiationItems: [concurrentItem] }) })))
  let response = await request({ body: switchboardRequest({ address: 'concurrent-recipient' }) })
  assert.deepEqual(response.body.negotiationItems.map(item => item.id), ['concurrent-id'])

  const expiringItem = negotiationItem('expiring-id', { forAddress: 'expiry-recipient' })
  await request({ body: switchboardRequest({ networkId: 'expiry-network', negotiationItems: [expiringItem] }) })
  const originalNow = Date.now
  Date.now = () => originalNow() + 30_001
  try {
    response = await request({ body: switchboardRequest({ networkId: 'expiry-network', address: 'expiry-recipient' }) })
    assert.deepEqual(response.body.negotiationItems, [])
  } finally {
    Date.now = originalNow
  }
})

test('enforces request and per-network negotiation capacity limits', async () => {
  const tooManyItems = Array.from({ length: 101 }, (_, index) => negotiationItem(`request-limit-${index}`))
  let response = await request({ body: switchboardRequest({ negotiationItems: tooManyItems }) })
  assert.equal(response.status, 400)

  for (let batch = 0; batch < 6; batch++) {
    const negotiationItems = Array.from({ length: 100 }, (_, index) => negotiationItem(`capacity-${batch}-${index}`, {
      fromAddress: 'capacity-sender',
      forAddress: 'capacity-recipient',
      networkId: 'capacity-network'
    }))
    response = await request({ body: switchboardRequest({ networkId: 'capacity-network', address: 'capacity-sender', negotiationItems }) })
    assert.equal(response.status, 200)
  }

  response = await request({ body: switchboardRequest({ networkId: 'capacity-network', address: 'capacity-recipient' }) })
  assert.equal(response.status, 200)
  assert.equal(response.body.negotiationItems.length, 500)
}, { timeout: 10000 })