acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-node-server/tests/adapter/listener.test.ts

@@ -0,0 +1,727 @@
+import { EventEmitter } from 'node:events'
+import { createServer } from 'node:http'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import {
+  connect as http2Connect,
+  constants as http2Constants,
+  createServer as createHttp2Server,
+} from 'node:http2'
+import type { AddressInfo } from 'node:net'
+import { Readable } from 'node:stream'
+import { GlobalHeaders } from '../../src/adapter/headers.ts'
+import { getRequestListener } from '../../src/adapter/listener.ts'
+import { GlobalRequest, Request as LightweightRequest, RequestError } from '../../src/adapter/request.ts'
+import { GlobalResponse, Response as LightweightResponse } from '../../src/adapter/response.ts'
+import { requestServer } from './helpers/request.ts'
+
+const withTimeout = async <T>(promise: Promise<T>, message: string): Promise<T> => {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined
+
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<T>((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(message))
+        }, 1_000)
+      }),
+    ])
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId)
+    }
+  }
+}
+
+const runRequestAndCollectOutgoingEvents = async (
+  fetchCallback: Parameters<typeof getRequestListener>[0]
+): Promise<{
+  closeListenerCount: number
+  response: Response
+}> => {
+  let closeListenerCount = 0
+  const requestListener = getRequestListener(fetchCallback)
+  const server = createServer(async (req, res) => {
+    const originalOn = res.on.bind(res)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(res as any).on = ((event: string, listener: (...args: any[]) => void) => {
+      if (event === 'close') {
+        closeListenerCount++
+      }
+      return originalOn(event, listener)
+    }) as typeof res.on
+
+    await requestListener(req, res)
+  })
+
+  const response = await requestServer(server, { method: 'GET', path: '/' })
+  return { closeListenerCount, response }
+}
+
+describe('Invalid request', () => {
+  describe('default error handler', () => {
+    const requestListener = getRequestListener(vi.fn())
+    const server = createServer(requestListener)
+
+    it('Should return server error for a request w/o host header', async () => {
+      const res = await requestServer(server, {
+        method: 'GET',
+        path: '/',
+        headers: { host: '' },
+        setHost: false,
+      })
+      expect(res.status).toBe(400)
+    })
+
+    it('Should return server error for a request invalid host header', async () => {
+      const res = await requestServer(server, {
+        method: 'GET',
+        path: '/',
+        headers: { host: 'a b' },
+      })
+      expect(res.status).toBe(400)
+    })
+  })
+
+  describe('custom error handler', () => {
+    const requestListener = getRequestListener(vi.fn(), {
+      errorHandler: (e) => {
+        if (e instanceof RequestError) {
+          return new Response(e.message, { status: 400 })
+        } else {
+          return new Response('unknown error', { status: 500 })
+        }
+      },
+    })
+    const server = createServer(requestListener)
+
+    it('Should return server error for a request w/o host header', async () => {
+      const res = await requestServer(server, {
+        method: 'GET',
+        path: '/',
+        headers: { host: '' },
+        setHost: false,
+      })
+      expect(res.status).toBe(400)
+    })
+
+    it('Should return server error for a request invalid host header', async () => {
+      const res = await requestServer(server, {
+        method: 'GET',
+        path: '/',
+        headers: { host: 'a b' },
+      })
+      expect(res.status).toBe(400)
+    })
+
+    it('Should return server error for host header with path', async () => {
+      const res = await requestServer(server, {
+        method: 'GET',
+        path: '/',
+        headers: { host: 'a/b' },
+      })
+      expect(res.status).toBe(400)
+    })
+  })
+
+  describe('default hostname', () => {
+    const requestListener = getRequestListener(() => new Response('ok'), {
+      hostname: 'example.com',
+    })
+    const server = createServer(requestListener)
+
+    it('Should return 200 for a request w/o host header', async () => {
+      const res = await requestServer(server, {
+        method: 'GET',
+        path: '/',
+        headers: { host: '' },
+        setHost: false,
+      })
+      expect(res.status).toBe(200)
+    })
+
+    it('Should return server error for a request invalid host header', async () => {
+      const res = await requestServer(server, {
+        method: 'GET',
+        path: '/',
+        headers: { host: 'a b' },
+      })
+      expect(res.status).toBe(400)
+    })
+  })
+
+  describe('malformed body response', () => {
+    const malformedResponse = {
+      body: 'content',
+    }
+    const requestListener = getRequestListener(() => malformedResponse, {
+      hostname: 'example.com',
+    })
+    const server = createServer(requestListener)
+
+    it('Should return a 500 for a malformed response', async () => {
+      const res = await requestServer(server, { method: 'GET', path: '/' })
+      expect(res.status).toBe(500)
+    })
+  })
+})
+
+describe('Response headers', () => {
+  const requestListener = getRequestListener(() => new Response(null), {
+    hostname: 'example.com',
+  })
+  const server = createServer(requestListener)
+
+  it('Should not set content-type for a null body response', async () => {
+    const res = await requestServer(server, { method: 'GET', path: '/' })
+    expect(res.status).toBe(200)
+    expect(res.headers.get('content-type')).toBeNull()
+    expect(await res.text()).toBe('')
+  })
+})
+
+describe('Error handling - sync fetchCallback', () => {
+  const fetchCallback = vi.fn(() => {
+    throw new Error('thrown error')
+  })
+  const errorHandler = vi.fn()
+
+  const requestListener = getRequestListener(fetchCallback, { errorHandler })
+
+  const server = createServer(async (req, res) => {
+    await requestListener(req, res)
+
+    if (!res.writableEnded) {
+      res.writeHead(500, { 'Content-Type': 'text/plain' })
+      res.end('error handler did not return a response')
+    }
+  })
+
+  beforeEach(() => {
+    errorHandler.mockReset()
+  })
+
+  it('Should set the response if error handler returns a response', async () => {
+    errorHandler.mockImplementationOnce((err: Error) => {
+      return new Response(`${err}`, { status: 500, headers: { 'my-custom-header': 'hi' } })
+    })
+
+    const res = await requestServer(server, { method: 'GET', path: '/throw-error' })
+    expect(res.status).toBe(500)
+    expect(res.headers.get('my-custom-header')).toBe('hi')
+    expect(await res.text()).toBe('Error: thrown error')
+  })
+
+  it('Should not set the response if the error handler does not return a response', async () => {
+    errorHandler.mockImplementationOnce(() => {
+      // do something else, such as passing error to vite next middleware, etc
+    })
+
+    const res = await requestServer(server, { method: 'GET', path: '/throw-error' })
+    expect(errorHandler).toHaveBeenCalledTimes(1)
+    expect(res.status).toBe(500)
+    expect(await res.text()).toBe('error handler did not return a response')
+  })
+})
+
+describe('Error handling - async fetchCallback', () => {
+  const fetchCallback = vi.fn(async () => {
+    throw new Error('thrown error')
+  })
+  const errorHandler = vi.fn()
+
+  const requestListener = getRequestListener(fetchCallback, { errorHandler })
+
+  const server = createServer(async (req, res) => {
+    await requestListener(req, res)
+
+    if (!res.writableEnded) {
+      res.writeHead(500, { 'Content-Type': 'text/plain' })
+      res.end('error handler did not return a response')
+    }
+  })
+
+  beforeEach(() => {
+    errorHandler.mockReset()
+  })
+
+  it('Should set the response if error handler returns a response', async () => {
+    errorHandler.mockImplementationOnce((err: Error) => {
+      return new Response(`${err}`, { status: 500, headers: { 'my-custom-header': 'hi' } })
+    })
+
+    const res = await requestServer(server, { method: 'GET', path: '/throw-error' })
+    expect(res.status).toBe(500)
+    expect(res.headers.get('my-custom-header')).toBe('hi')
+    expect(await res.text()).toBe('Error: thrown error')
+  })
+
+  it('Should not set the response if the error handler does not return a response', async () => {
+    errorHandler.mockImplementationOnce(() => {
+      // do something else, such as passing error to vite next middleware, etc
+    })
+
+    const res = await requestServer(server, { method: 'GET', path: '/throw-error' })
+    expect(errorHandler).toHaveBeenCalledTimes(1)
+    expect(res.status).toBe(500)
+    expect(await res.text()).toBe('error handler did not return a response')
+  })
+})
+
+describe('Abort request', () => {
+  let onAbort: (req: Request) => void
+  let reqReadyResolve: () => void
+  let reqReadyPromise: Promise<void>
+  const fetchCallback = async (req: Request) => {
+    req.signal.addEventListener('abort', () => onAbort(req))
+    reqReadyResolve?.()
+    await new Promise(() => {}) // never resolve
+  }
+
+  const requestListener = getRequestListener(fetchCallback)
+
+  const server = createServer(async (req, res) => {
+    await requestListener(req, res)
+  })
+
+  beforeEach(() => {
+    reqReadyPromise = new Promise<void>((r) => {
+      reqReadyResolve = r
+    })
+  })
+
+  it.each(['get', 'put', 'patch', 'delete'] as const)(
+    'should emit an abort event when the nodejs %s request is aborted',
+    async (method) => {
+      const requests: Request[] = []
+      const abortedPromise = new Promise<void>((resolve) => {
+        onAbort = (req) => {
+          requests.push(req)
+          resolve()
+        }
+      })
+
+      const controller = new AbortController()
+      const resPromise = requestServer(server, {
+        method: method.toUpperCase(),
+        path: '/abort',
+        signal: controller.signal,
+      }).catch(() => {})
+
+      await reqReadyPromise
+
+      controller.abort()
+
+      await abortedPromise
+      await resPromise
+
+      expect(requests).toHaveLength(1)
+      const abortedReq = requests[0]
+      expect(abortedReq).toBeInstanceOf(Request)
+      expect(abortedReq.signal.aborted).toBe(true)
+    }
+  )
+
+  it.each(['get', 'post', 'head', 'patch', 'delete', 'put'] as const)(
+    'should emit an abort event when the nodejs request is aborted on multiple %s requests',
+    async (method) => {
+      const requests: Request[] = []
+
+      {
+        const abortedPromise = new Promise<void>((resolve) => {
+          onAbort = (req) => {
+            requests.push(req)
+            resolve()
+          }
+        })
+
+        reqReadyPromise = new Promise<void>((r) => {
+          reqReadyResolve = r
+        })
+
+        const controller = new AbortController()
+        const resPromise = requestServer(server, {
+          method: method.toUpperCase(),
+          path: '/abort',
+          signal: controller.signal,
+        }).catch(() => {})
+
+        await reqReadyPromise
+
+        controller.abort()
+
+        await abortedPromise
+        await resPromise
+      }
+
+      expect(requests).toHaveLength(1)
+
+      for (const abortedReq of requests) {
+        expect(abortedReq).toBeInstanceOf(Request)
+        expect(abortedReq.signal.aborted).toBe(true)
+      }
+
+      {
+        const abortedPromise = new Promise<void>((resolve) => {
+          onAbort = (req) => {
+            requests.push(req)
+            resolve()
+          }
+        })
+
+        reqReadyPromise = new Promise<void>((r) => {
+          reqReadyResolve = r
+        })
+
+        const controller = new AbortController()
+        const resPromise = requestServer(server, {
+          method: method.toUpperCase(),
+          path: '/abort',
+          signal: controller.signal,
+        }).catch(() => {})
+
+        await reqReadyPromise
+
+        controller.abort()
+
+        await abortedPromise
+        await resPromise
+      }
+
+      expect(requests).toHaveLength(2)
+
+      for (const abortedReq of requests) {
+        expect(abortedReq).toBeInstanceOf(Request)
+        expect(abortedReq.signal.aborted).toBe(true)
+      }
+    }
+  )
+
+  it('should handle request abort without requestCache', async () => {
+    const fetchCallback = async () => {
+      // NOTE: we don't req.signal
+      await new Promise(() => {}) // never resolve
+    }
+    const requestListener = getRequestListener(fetchCallback)
+    const server = createServer(requestListener)
+    const req = requestServer(server, {
+      method: 'POST',
+      path: '/abort',
+      signal: AbortSignal.timeout(1),
+    })
+    await expect(req).rejects.toThrow()
+  })
+
+  it.each(['stream', 'session'] as const)(
+    'should emit an abort event when an HTTP/2 client closes the %s',
+    async (target) => {
+      let resolveReady!: () => void
+      const ready = new Promise<void>((r) => {
+        resolveReady = r
+      })
+      let resolveAborted!: (req: Request) => void
+      const aborted = new Promise<Request>((r) => {
+        resolveAborted = r
+      })
+
+      const server = createHttp2Server(
+        getRequestListener(async (req: Request) => {
+          req.signal.addEventListener('abort', () => resolveAborted(req))
+          resolveReady()
+          await new Promise(() => {}) // never resolve
+        })
+      )
+      await new Promise<void>((r) => server.listen(0, '127.0.0.1', r))
+      const { port } = server.address() as AddressInfo
+      const client = http2Connect(`http://127.0.0.1:${port}`)
+
+      try {
+        const stream = client.request({ ':path': '/abort' })
+        stream.on('error', () => {})
+        await withTimeout(ready, 'request did not reach the handler')
+
+        if (target === 'stream') {
+          stream.close(http2Constants.NGHTTP2_CANCEL)
+        } else {
+          client.destroy()
+        }
+
+        const req = await withTimeout(aborted, 'abort signal did not fire')
+        expect(req.signal.aborted).toBe(true)
+      } finally {
+        client.destroy()
+        await new Promise<void>((r) => server.close(() => r()))
+      }
+    }
+  )
+})
+
+describe('Abort request - error path', () => {
+  const runAbortDuringErrorHandlerCase = async (mode: 'sync' | 'async') => {
+    let capturedReq: Request | undefined
+    let resolveAborted!: () => void
+    const abortedPromise = new Promise<void>((r) => {
+      resolveAborted = r
+    })
+
+    let resolveErrorHandlerStarted!: () => void
+    const errorHandlerStarted = new Promise<void>((r) => {
+      resolveErrorHandlerStarted = r
+    })
+
+    const onRequest = (req: Request) => {
+      capturedReq = req
+      req.signal.addEventListener('abort', resolveAborted)
+    }
+
+    const fetchCallback =
+      mode === 'sync'
+        ? (req: Request) => {
+            onRequest(req)
+            throw new Error('sync error')
+          }
+        : async (req: Request) => {
+            onRequest(req)
+            throw new Error('async error')
+          }
+
+    const errorHandler = async () => {
+      resolveErrorHandlerStarted()
+      await new Promise<void>(() => {}) // never resolves — client will disconnect first
+    }
+
+    const requestListener = getRequestListener(fetchCallback, { errorHandler })
+    const server = createServer(requestListener)
+
+    const controller = new AbortController()
+    const resPromise = requestServer(server, {
+      method: 'GET',
+      path: '/',
+      signal: controller.signal,
+    }).catch(() => {})
+    await withTimeout(errorHandlerStarted, 'error handler did not start')
+    controller.abort()
+    await withTimeout(abortedPromise, 'request abort did not propagate')
+    expect(capturedReq?.signal.aborted).toBe(true)
+    await resPromise
+  }
+
+  it.each(['sync', 'async'] as const)(
+    'should abort request signal when client disconnects while async error handler is running after %s',
+    async (mode) => {
+      await runAbortDuringErrorHandlerCase(mode)
+    }
+  )
+})
+
+describe('Abort request - cacheable response path', () => {
+  it.each([
+    ['string', () => new Response('fast path')],
+    ['Uint8Array', () => new Response(new TextEncoder().encode('fast path'))],
+    ['null', () => new Response(null, { status: 204 })],
+  ] as const)(
+    'should avoid attaching a close listener for sync immediate cacheable %s responses',
+    async (_type, createResponse) => {
+      const { closeListenerCount, response } = await runRequestAndCollectOutgoingEvents(() =>
+        createResponse()
+      )
+
+      expect(closeListenerCount).toBe(0)
+
+      if (response.status === 204) {
+        expect(response.body).toBeNull()
+      } else {
+        expect(await response.text()).toBe('fast path')
+      }
+    }
+  )
+
+  it('should attach a close listener and send the body for sync Blob responses', async () => {
+    const { closeListenerCount, response } = await runRequestAndCollectOutgoingEvents(
+      () =>
+        new Response(new Blob(['blob-body']), {
+          headers: {
+            'content-type': 'text/plain; charset=UTF-8',
+          },
+        })
+    )
+
+    expect(closeListenerCount).toBe(1)
+    expect(await response.text()).toBe('blob-body')
+  })
+
+  it('should abort request signal when client disconnects during sync cacheable ReadableStream response', async () => {
+    let resolveAborted!: () => void
+    const abortedPromise = new Promise<void>((r) => {
+      resolveAborted = r
+    })
+
+    let capturedReq: Request | undefined
+    let resolveStreamConstructed!: () => void
+    const streamConstructed = new Promise<void>((r) => {
+      resolveStreamConstructed = r
+    })
+
+    const fetchCallback = (req: Request) => {
+      capturedReq = req
+      req.signal.addEventListener('abort', resolveAborted)
+
+      const body = new ReadableStream({
+        start() {
+          resolveStreamConstructed()
+        },
+        async pull() {
+          await new Promise<void>(() => {}) // never resolves — client will disconnect first
+        },
+      })
+
+      return new Response(body)
+    }
+
+    const requestListener = getRequestListener(fetchCallback)
+    const server = createServer(requestListener)
+
+    const controller = new AbortController()
+    const resPromise = requestServer(server, {
+      method: 'GET',
+      path: '/',
+      signal: controller.signal,
+    }).catch(() => {})
+    await withTimeout(streamConstructed, 'stream body was not constructed')
+    controller.abort()
+    await withTimeout(abortedPromise, 'request abort did not propagate for cacheable stream')
+    expect(capturedReq?.signal.aborted).toBe(true)
+    await resPromise
+  })
+})
+
+describe('Non-standard incoming request', () => {
+  class MockSocket extends EventEmitter {
+    remoteAddress = '127.0.0.1'
+    remotePort = 44936
+  }
+
+  class MockIncomingMessage extends Readable {
+    method = 'POST'
+    url = '/'
+    headers = { host: 'localhost' }
+    rawHeaders = ['host', 'localhost']
+
+    constructor(readonly socket: EventEmitter = new MockSocket()) {
+      super()
+    }
+
+    _read() {
+      // The body is never pushed and never ends, so draining cannot complete
+      // and the drain timeout is guaranteed to fire.
+    }
+  }
+
+  class MockServerResponse extends EventEmitter {
+    headersSent = false
+    writableFinished = false
+
+    writeHead() {
+      this.headersSent = true
+      return this
+    }
+
+    end() {
+      this.writableFinished = true
+      this.emit('finish')
+      this.emit('close')
+      return this
+    }
+  }
+
+  it('Should not throw when the drain timeout fires on a socket without destroySoon', async () => {
+    vi.useFakeTimers()
+
+    try {
+      const requestListener = getRequestListener(() => new LightweightResponse('ok'))
+      await requestListener(
+        new MockIncomingMessage() as unknown as IncomingMessage,
+        new MockServerResponse() as unknown as ServerResponse
+      )
+
+      // The drain timeout fires on a timer, so a throw here is an uncatchable
+      // uncaughtException for the caller.
+      expect(() => vi.advanceTimersByTime(1_000)).not.toThrow()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('Should destroy a socket that implements destroy but not destroySoon', async () => {
+    vi.useFakeTimers()
+
+    try {
+      // Duplex-based fakes provide the standard stream teardown method only.
+      class DuplexLikeSocket extends MockSocket {
+        destroy = vi.fn()
+      }
+      const socket = new DuplexLikeSocket()
+
+      const requestListener = getRequestListener(() => new LightweightResponse('ok'))
+      await requestListener(
+        new MockIncomingMessage(socket) as unknown as IncomingMessage,
+        new MockServerResponse() as unknown as ServerResponse
+      )
+      vi.advanceTimersByTime(1_000)
+
+      expect(socket.destroy).toHaveBeenCalledTimes(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('overrideGlobalObjects', () => {
+  const fetchCallback = vi.fn()
+
+  beforeEach(() => {
+    Object.defineProperty(global, 'Headers', {
+      value: GlobalHeaders,
+      writable: true,
+    })
+    Object.defineProperty(global, 'Request', {
+      value: GlobalRequest,
+      writable: true,
+    })
+    Object.defineProperty(global, 'Response', {
+      value: GlobalResponse,
+      writable: true,
+    })
+  })
+
+  describe('default', () => {
+    it('Should be overridden', () => {
+      getRequestListener(fetchCallback)
+      expect(global.Headers).toBe(GlobalHeaders)
+      expect(global.Request).toBe(LightweightRequest)
+      expect(global.Response).toBe(LightweightResponse)
+    })
+  })
+
+  describe('overrideGlobalObjects: true', () => {
+    it('Should be overridden', () => {
+      getRequestListener(fetchCallback, {
+        overrideGlobalObjects: true,
+      })
+      expect(global.Headers).toBe(GlobalHeaders)
+      expect(global.Request).toBe(LightweightRequest)
+      expect(global.Response).toBe(LightweightResponse)
+    })
+  })
+
+  describe('overrideGlobalObjects: false', () => {
+    it('Should not be overridden', () => {
+      getRequestListener(fetchCallback, {
+        overrideGlobalObjects: false,
+      })
+      expect(global.Headers).toBe(GlobalHeaders)
+      expect(global.Request).toBe(GlobalRequest)
+      expect(global.Response).toBe(GlobalResponse)
+    })
+  })
+})