acrylblends 0.2.0 → 0.4.0

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

@@ -0,0 +1,252 @@
+import type { IncomingMessage } from 'node:http'
+import { Http2ServerRequest } from 'node:http2'
+import type { ServerHttp2Stream } from 'node:http2'
+import { Duplex } from 'node:stream'
+import { inspect } from 'node:util'
+import { GlobalHeaders, RequestHeaders, newHeadersFromIncoming } from '../../src/adapter/headers.ts'
+import { newRequest, Request as LightweightRequest } from '../../src/adapter/request.ts'
+
+// Compatibility cases adapted from srvx's Node header suite:
+// https://github.com/h3js/srvx/blob/4052594e76d5ead2cc4c7cf8f7fa6d5ea9558a0a/test/node-headers.test.ts
+
+const incoming = (rawHeaders: string[], headers: Record<string, unknown>): IncomingMessage =>
+  ({ rawHeaders, headers }) as IncomingMessage
+
+const incomingHttp2 = (
+  rawHeaders: string[],
+  headers: Record<string, string | string[]>
+): Http2ServerRequest =>
+  new Http2ServerRequest(new Duplex() as ServerHttp2Stream, headers, {}, rawHeaders)
+
+const lightweightHeaders = (request: IncomingMessage | Http2ServerRequest): GlobalHeaders =>
+  newHeadersFromIncoming(request)
+
+const nonJoinedHeaderNames = [
+  'age',
+  'authorization',
+  'content-length',
+  'content-type',
+  'etag',
+  'expires',
+  'from',
+  'host',
+  'if-modified-since',
+  'if-unmodified-since',
+  'last-modified',
+  'location',
+  'max-forwards',
+  'proxy-authorization',
+  'referer',
+  'retry-after',
+  'server',
+  'user-agent',
+]
+
+describe('RequestHeaders', () => {
+  it('reads common headers without iterating rawHeaders', () => {
+    let rawHeadersReads = 0
+    const request = {
+      headers: { 'x-test': 'value' },
+      get rawHeaders() {
+        rawHeadersReads++
+        return ['x-test', 'value']
+      },
+    } as unknown as IncomingMessage
+
+    const headers = lightweightHeaders(request)
+
+    expect(headers).toBeInstanceOf(GlobalHeaders)
+    expect(headers.get('X-Test')).toBe('value')
+    expect(headers.has('x-test')).toBe(true)
+    expect(rawHeadersReads).toBe(0)
+    expect(() => headers.get('bad name')).toThrow(TypeError)
+    expect(() => headers.has(':path')).toThrow(TypeError)
+    expect(rawHeadersReads).toBe(0)
+
+    expect([...headers]).toEqual([['x-test', 'value']])
+    expect(rawHeadersReads).toBe(1)
+  })
+
+  it.each(nonJoinedHeaderNames)(
+    'combines repeated %s values consistently before and after iteration',
+    (name) => {
+      const rawHeaders = [name, 'one', name, 'two']
+      const collapsed = { [name]: 'one' }
+
+      const before = lightweightHeaders(incoming(rawHeaders, collapsed))
+      expect(before.get(name)).toBe('one, two')
+      expect(before.has(name)).toBe(true)
+
+      const after = lightweightHeaders(incoming(rawHeaders, collapsed))
+      void [...after]
+      expect(after.get(name)).toBe('one, two')
+    }
+  )
+
+  it('combines headers collapsed by the HTTP/2 parser', () => {
+    const headers = lightweightHeaders(
+      incomingHttp2(['if-none-match', '"a"', 'if-none-match', '"b"'], {
+        'if-none-match': '"a"',
+      })
+    )
+
+    expect(headers.get('if-none-match')).toBe('"a", "b"')
+    void [...headers]
+    expect(headers.get('if-none-match')).toBe('"a", "b"')
+  })
+
+  it('uses an immutable raw-header snapshot for HTTP/2', () => {
+    const rawHeaders = ['x-secret', 'topsecret', 'host', 'localhost']
+    const request = incomingHttp2(rawHeaders, {
+      'x-secret': 'topsecret',
+      host: 'localhost',
+    })
+    const headers = lightweightHeaders(request)
+
+    delete request.headers['x-secret']
+    request.headers['x-added'] = 'value'
+    rawHeaders[1] = 'changed'
+    rawHeaders.push('x-added', 'value')
+
+    expect(headers.get('x-secret')).toBe('topsecret')
+    expect(headers.has('x-added')).toBe(false)
+    void [...headers]
+    expect(headers.get('x-secret')).toBe('topsecret')
+    expect(headers.has('x-added')).toBe(false)
+  })
+
+  it('ignores non-string values in synthesized parsed headers', () => {
+    const headers = lightweightHeaders(
+      incoming(['content-length', '123'], { 'content-length': 123 })
+    )
+
+    expect(headers.get('content-length')).toBe('123')
+    expect(headers.has('content-length')).toBe(true)
+    void [...headers]
+    expect(headers.get('content-length')).toBe('123')
+  })
+
+  it('normalizes raw values consistently before and after materialization', () => {
+    const rawHeaders = ['x-token', '  abc\t', 'x-tab', '\tv v\t', 'x-interior', 'a  b']
+    const headers = lightweightHeaders(incomingHttp2(rawHeaders, {}))
+
+    expect(headers.get('x-token')).toBe('abc')
+    expect(headers.get('x-tab')).toBe('v v')
+    expect(headers.get('x-interior')).toBe('a  b')
+    void [...headers]
+    expect(headers.get('x-token')).toBe('abc')
+    expect(headers.get('x-tab')).toBe('v v')
+    expect(headers.get('x-interior')).toBe('a  b')
+  })
+
+  it('fails closed on values rejected by native Headers', () => {
+    const rawHeaders = ['x-evil', 'ok', 'x-evil', 'bad\0value']
+
+    expect(() => lightweightHeaders(incomingHttp2(rawHeaders, {})).get('x-evil')).toThrow(TypeError)
+    expect(() => lightweightHeaders(incomingHttp2(rawHeaders, {})).has('x-evil')).toThrow(TypeError)
+    expect(() => [...lightweightHeaders(incomingHttp2(rawHeaders, {}))]).toThrow(TypeError)
+  })
+
+  it('preserves cookie and set-cookie representations', () => {
+    const headers = lightweightHeaders(
+      incoming(['cookie', 'a=1', 'cookie', 'b=2', 'set-cookie', 'a=1', 'set-cookie', 'b=2'], {
+        cookie: 'a=1; b=2',
+        'set-cookie': ['ignored'],
+      })
+    )
+
+    expect(headers.get('cookie')).toBe('a=1; b=2')
+    expect(headers.get('set-cookie')).toBe('a=1, b=2')
+    expect(headers.getSetCookie()).toEqual(['a=1', 'b=2'])
+    expect(Object.fromEntries(headers).cookie).toBe('a=1; b=2')
+  })
+
+  it('reads a literal __proto__ header without exposing prototype properties', () => {
+    const headers = lightweightHeaders(
+      incoming(['__proto__', 'value', 'x-test', 'one'], { 'x-test': 'one' })
+    )
+
+    expect(headers.get('__proto__')).toBe('value')
+    expect(headers.has('__proto__')).toBe(true)
+    expect(headers.get('toString')).toBe(null)
+    expect(headers.has('toString')).toBe(false)
+  })
+
+  it('materializes for validation and mutation while preserving identity', () => {
+    const headers = lightweightHeaders(incoming(['host', 'localhost'], { host: 'localhost' }))
+
+    expect(() => headers.get('bad name')).toThrow(TypeError)
+    expect(() => headers.has(':path')).toThrow(TypeError)
+    headers.set('x-test', 'value')
+    headers.append('x-test', 'second')
+
+    expect(headers.get('x-test')).toBe('value, second')
+    let callbackParent: GlobalHeaders | undefined
+    headers.forEach((_value, _key, parent) => {
+      callbackParent = parent
+    })
+    expect(callbackParent).toBe(headers)
+  })
+
+  it('uses the lightweight inspection format', () => {
+    const headers = lightweightHeaders(incoming(['x-test', 'value'], { 'x-test': 'value' }))
+
+    expect(inspect(headers)).toContain("Headers (lightweight) { 'x-test': 'value' }")
+  })
+
+  it('leaves the standard Headers constructor unchanged', () => {
+    const headers = new Headers({ 'x-test': 'one' })
+    headers.append('x-test', 'two')
+
+    expect(global.Headers).toBe(GlobalHeaders)
+    expect(Object.getPrototypeOf(headers)).toBe(GlobalHeaders.prototype)
+    expect(headers.get('x-test')).toBe('one, two')
+    expect(new Headers(headers).get('x-test')).toBe('one, two')
+    expect(new Headers({ rawHeaders: 'ordinary value' }).get('rawHeaders')).toBe('ordinary value')
+  })
+
+  it('uses the internal implementation without replacing the global constructor', () => {
+    const request = incoming(['x-test', 'value'], { 'x-test': 'value' })
+    const headers = newHeadersFromIncoming(request)
+
+    expect(global.Headers).toBe(GlobalHeaders)
+    expect(Object.getPrototypeOf(headers)).toBe(RequestHeaders.prototype)
+    expect(headers).toBeInstanceOf(GlobalHeaders)
+    expect(new GlobalHeaders(headers).get('x-test')).toBe('value')
+  })
+
+  it('uses the live global Headers constructor when it changes after module initialization', () => {
+    class PolyfillHeaders extends GlobalHeaders {}
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'Headers')
+    Object.defineProperty(globalThis, 'Headers', {
+      value: PolyfillHeaders,
+      configurable: true,
+      writable: true,
+    })
+
+    try {
+      const headers = newHeadersFromIncoming(incoming(['x-test', 'value'], { 'x-test': 'value' }))
+
+      expect(headers).toBeInstanceOf(PolyfillHeaders)
+      expect(Object.getPrototypeOf(headers)).toBe(PolyfillHeaders.prototype)
+      expect(headers.get('x-test')).toBe('value')
+    } finally {
+      Object.defineProperty(globalThis, 'Headers', descriptor!)
+    }
+  })
+
+  it('can initialize and clone a native Request after header mutation', () => {
+    const request = newRequest({
+      method: 'GET',
+      url: '/',
+      headers: { host: 'localhost' },
+      rawHeaders: ['host', 'localhost'],
+    } as IncomingMessage)
+    const headers = request.headers
+    headers.set('x-test', 'value')
+
+    expect(request.keepalive).toBe(false)
+    expect(request.headers).toBe(headers)
+    expect(new LightweightRequest(request).headers.get('x-test')).toBe('value')
+  })
+})

package/plugins/acryl-node-server/tests/adapter/helpers/request.ts

@@ -0,0 +1,190 @@
+import { once } from 'node:events'
+import { request as requestHTTP } from 'node:http'
+import type { IncomingMessage, RequestOptions } from 'node:http'
+import { connect } from 'node:http2'
+import type { IncomingHttpHeaders as IncomingHttp2Headers } from 'node:http2'
+import { Server as HttpsServer, request as requestHTTPS } from 'node:https'
+import type { AddressInfo } from 'node:net'
+import { newHeadersFromIncoming } from '../../../src/adapter/headers.ts'
+import { GlobalResponse } from '../../../src/adapter/response.ts'
+import type { ServerType } from '../../../src/adapter/types.ts'
+
+export type ServerRequestInit = Omit<
+  RequestOptions,
+  'agent' | 'host' | 'hostname' | 'path' | 'port' | 'protocol'
+> & {
+  body?: string | Uint8Array
+  path: string
+}
+
+export type ServerRequestHooks = {
+  onHeaders?: (headers: Headers, status: number) => void
+  onChunk?: (chunk: Buffer, index: number) => void
+}
+
+export type Http2RequestInit = {
+  headers?: Record<string, string>
+  method?: string
+  path: string
+}
+
+const ensureListening = async (server: ServerType) => {
+  let address = server.address() as AddressInfo | null
+  let startedByHelper = false
+  if (!address) {
+    server.listen(0, '127.0.0.1')
+    await once(server, 'listening')
+    startedByHelper = true
+    address = server.address() as AddressInfo | null
+  }
+  if (!address) {
+    throw new Error('Server is not listening on a TCP address')
+  }
+
+  return {
+    address,
+    // a no-op if the server was already listening before the request, its
+    // owner is responsible for closing it in that case
+    close: async () => {
+      if (startedByHelper) {
+        await new Promise<void>((resolve) => server.close(() => resolve()))
+      }
+    },
+  }
+}
+
+const sendRequest = (server: ServerType, address: AddressInfo, init: ServerRequestInit) => {
+  const { body, path, ...options } = init
+  const common = {
+    ...options,
+    agent: false,
+    hostname: address.address,
+    path,
+    port: address.port,
+  }
+  const request =
+    server instanceof HttpsServer
+      ? requestHTTPS({ ...common, rejectUnauthorized: false })
+      : requestHTTP(common)
+  request.end(body)
+  return request
+}
+
+const receiveResponse = async (request: ReturnType<typeof sendRequest>) => {
+  const [incoming] = (await once(request, 'response')) as [IncomingMessage]
+  const status = incoming.statusCode
+  if (!status) {
+    throw new Error('Server response did not include a status code')
+  }
+  return { incoming, status }
+}
+
+export const requestServer = async (
+  server: ServerType,
+  init: ServerRequestInit
+): Promise<Response> => {
+  const { address, close } = await ensureListening(server)
+
+  // the request may fail mid-flight (e.g. aborted via `init.signal`), so the
+  // helper-started server is always fully closed before returning or
+  // surfacing an error
+  try {
+    const { incoming, status } = await receiveResponse(sendRequest(server, address, init))
+
+    const hasBody = init.method?.toUpperCase() !== 'HEAD' && ![101, 204, 205, 304].includes(status)
+
+    let responseBody: BodyInit | null = null
+    if (hasBody) {
+      // buffer the body so a helper-started server can be fully closed before
+      // returning, otherwise a subsequent request could hit a half-closed server
+      const chunks: Buffer[] = []
+      for await (const chunk of incoming) {
+        chunks.push(chunk)
+      }
+      responseBody = new Uint8Array(Buffer.concat(chunks))
+    }
+
+    return new GlobalResponse(responseBody, {
+      headers: newHeadersFromIncoming(incoming),
+      status,
+      statusText: incoming.statusMessage,
+    })
+  } finally {
+    await close()
+  }
+}
+
+/**
+ * Same as `requestServer`, but exposes the raw body chunks for tests that
+ * assert streaming behavior: `onHeaders` fires before any body data arrives
+ * and `onChunk` fires per received chunk, so a test can synchronize with the
+ * server mid-response. Chunk boundaries are preserved by the chunked
+ * transfer-encoding framing.
+ */
+export const requestServerChunked = async (
+  server: ServerType,
+  init: ServerRequestInit,
+  hooks: ServerRequestHooks = {}
+): Promise<{ chunks: Buffer[]; response: Response }> => {
+  const { address, close } = await ensureListening(server)
+
+  try {
+    const { incoming, status } = await receiveResponse(sendRequest(server, address, init))
+    const headers = newHeadersFromIncoming(incoming)
+    hooks.onHeaders?.(headers, status)
+
+    const chunks: Buffer[] = []
+    incoming.on('data', (chunk: Buffer) => {
+      hooks.onChunk?.(chunk, chunks.length)
+      chunks.push(chunk)
+    })
+    await once(incoming, 'end')
+
+    return {
+      chunks,
+      response: new GlobalResponse(new Uint8Array(Buffer.concat(chunks)), {
+        headers,
+        status,
+        statusText: incoming.statusMessage,
+      }),
+    }
+  } finally {
+    await close()
+  }
+}
+
+export const requestServerHttp2 = async (
+  server: ServerType,
+  init: Http2RequestInit
+): Promise<Response> => {
+  const { address, close } = await ensureListening(server)
+  const client = connect(`http://${address.address}:${address.port}`)
+  // stream errors reject `once()` below, a session error would otherwise crash
+  client.once('error', () => {})
+
+  try {
+    const stream = client.request({
+      ':method': init.method ?? 'GET',
+      ':path': init.path,
+      ...init.headers,
+    })
+    stream.end()
+
+    const [incomingHeaders, , rawHeaders] = (await once(stream, 'response')) as [
+      IncomingHttp2Headers,
+      number,
+      string[],
+    ]
+    const status = Number(incomingHeaders[':status'])
+    const headers = newHeadersFromIncoming({ rawHeaders })
+
+    const chunks: Buffer[] = []
+    stream.on('data', (chunk: Buffer) => chunks.push(chunk))
+    await once(stream, 'end')
+
+    return new GlobalResponse(new Uint8Array(Buffer.concat(chunks)), { headers, status })
+  } finally {
+    client.close()
+    await close()
+  }
+}