acrylblends 0.6.2 → 0.6.4

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

@@ -1,252 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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()
-  }
-}