acrylblends 0.3.0 → 0.4.0

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.txt

@@ -0,0 +1 @@
+Hello Not Compressed

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.txt.br

@@ -0,0 +1 @@
+Hello br Compressed

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.txt.zst

@@ -0,0 +1 @@
+Hello zstd Compressed

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

@@ -0,0 +1,34 @@
+import { App } from '../../../acryl-router/src/index.ts'
+import type { AddressType, ConnInfo } from '../../../acryl-router/src/helpers/index.ts'
+import { getConnInfo } from '../../src/adapter/conninfo.ts'
+
+describe('ConnInfo', () => {
+  it('Should works', async () => {
+    const app = new App().get('/', (c) => c.json(getConnInfo(c)))
+
+    const socket = {
+      remoteAddress: '0.0.0.0',
+      remoteFamily: 'IPv4',
+      remotePort: 3030,
+    }
+    expect(
+      await (
+        await app.request(
+          '/',
+          {},
+          {
+            incoming: {
+              socket,
+            },
+          }
+        )
+      ).json()
+    ).toEqual({
+      remote: {
+        address: socket.remoteAddress,
+        addressType: socket.remoteFamily as AddressType,
+        port: socket.remotePort,
+      },
+    } satisfies ConnInfo)
+  })
+})

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

@@ -0,0 +1,248 @@
+import { App } from '../../../acryl-router/src/index.ts'
+import { once } from 'node:events'
+import { createServer } from 'node:http'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import { createServer as createHttp2Server } from 'node:http2'
+import { connect as connectNet } from 'node:net'
+import type { AddressInfo } from 'node:net'
+import { getRequestListener } from '../../src/adapter/listener.ts'
+import { defaultContentType } from '../../src/adapter/response.ts'
+import { createAdaptorServer } from '../../src/adapter/server.ts'
+import { requestServer, requestServerHttp2 } from './helpers/request.ts'
+
+// These tests exercise Node's real HTTP serializer. In addition to correctness,
+// assert that plain headers reach writeHead with the original record:
+// silently falling back to a copy must not hide a change to Node's internals.
+describe('automatic Content-Length compatibility', () => {
+  it.each(['', 'hello'])('serializes a frozen record without a copy: %j', async (body) => {
+    const headers = Object.freeze({ 'content-type': 'text/plain' })
+    let writeHeadCalls: unknown[][] = []
+    const listener = getRequestListener(() => new Response(body, { headers }))
+    const server = createServer((incoming, outgoing) => {
+      writeHeadCalls = vi.spyOn(outgoing, 'writeHead').mock.calls
+      void listener(incoming, outgoing)
+    })
+    const res = await requestServer(server, { path: '/' })
+    expect(res.status).toBe(200)
+    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(body)))
+    expect(res.headers.has('transfer-encoding')).toBe(false)
+    expect(await res.text()).toBe(body)
+    expect(writeHeadCalls[0][1]).toBe(headers)
+  })
+
+  it('preserves the byte length for c.json()', async () => {
+    const app = new App()
+    app.get('/', (c) => c.json({ message: 'hello' }))
+    const server = createServer(getRequestListener(app.fetch))
+    const res = await requestServer(server, { path: '/' })
+    const text = await res.text()
+    expect(JSON.parse(text)).toEqual({ message: 'hello' })
+    expect(res.headers.get('content-type')).toBe('application/json')
+    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(text)))
+    expect(res.headers.has('transfer-encoding')).toBe(false)
+  })
+
+  it('uses automatic length for JSON with a plain header record', async () => {
+    const headers = Object.freeze({ 'Content-Type': 'application/json' })
+    let writeHeadCalls: unknown[][] = []
+    const listener = getRequestListener(
+      () => new Response(JSON.stringify({ message: 'hello' }), { headers })
+    )
+    const server = createServer((incoming, outgoing) => {
+      writeHeadCalls = vi.spyOn(outgoing, 'writeHead').mock.calls
+      void listener(incoming, outgoing)
+    })
+    const res = await requestServer(server, { path: '/' })
+    const text = await res.text()
+    expect(JSON.parse(text)).toEqual({ message: 'hello' })
+    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(text)))
+    expect(writeHeadCalls[0][1]).toBe(headers)
+  })
+
+  it('uses the UTF-8 byte length for automatic Content-Length with c.text()', async () => {
+    const app = new App()
+    app.get('/', (c) => c.text('こんにちは'))
+    let writeHeadCalls: unknown[][] = []
+    const listener = getRequestListener(app.fetch)
+    const server = createServer((incoming, outgoing) => {
+      outgoing.strictContentLength = true
+      writeHeadCalls = vi.spyOn(outgoing, 'writeHead').mock.calls
+      void listener(incoming, outgoing)
+    })
+    const res = await requestServer(server, { path: '/' })
+    expect(await res.text()).toBe('こんにちは')
+    expect(res.headers.get('content-type')).toBe(defaultContentType)
+    expect(res.headers.get('content-length')).toBe('15')
+    expect(res.headers.has('transfer-encoding')).toBe(false)
+    expect(writeHeadCalls[0][1]).toEqual({ 'Content-Type': defaultContentType })
+  })
+
+  describe.each([
+    { protocol: 'HTTP/1.1', serverOptions: {}, request: requestServer },
+    {
+      protocol: 'HTTP/2',
+      serverOptions: { createServer: createHttp2Server },
+      request: requestServerHttp2,
+    },
+  ])('default headers over $protocol', ({ serverOptions, request }) => {
+    it.each([
+      { name: 'string', makeBody: (text: string) => text },
+      { name: 'Uint8Array', makeBody: (text: string) => new TextEncoder().encode(text) },
+      { name: 'Blob', makeBody: (text: string) => new Blob([text]) },
+    ])('preserves byte lengths for a $name body', async ({ makeBody }) => {
+      const bodies = ['', 'hello']
+      let index = 0
+      const server = createAdaptorServer({
+        fetch: () => new Response(makeBody(bodies[index++])),
+        ...serverOptions,
+      })
+      for (const body of bodies) {
+        const res = await request(server, { path: '/' })
+        expect(res.status).toBe(200)
+        expect(res.headers.get('content-type')).toBe(defaultContentType)
+        expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(body)))
+        expect(res.headers.has('transfer-encoding')).toBe(false)
+        expect(await res.text()).toBe(body)
+      }
+    })
+  })
+
+  it.each([204, 304])(
+    'preserves explicit length when status %i suppresses the body',
+    async (status) => {
+      const server = createServer(getRequestListener(() => new Response('hello', { status })))
+      const res = await requestServer(server, { path: '/' })
+      expect(res.status).toBe(status)
+      expect(res.headers.get('content-length')).toBe('5')
+      expect(await res.text()).toBe('')
+    }
+  )
+
+  describe.each([false, true])('custom headers: %s', (customHeaders) => {
+    it.each([
+      {
+        name: 'HEAD',
+        method: 'HEAD',
+        prepare: () => {},
+      },
+      {
+        name: 'previously set Content-Length',
+        method: 'GET',
+        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
+          outgoing.setHeader('Content-Length', '999')
+        },
+      },
+      {
+        name: 'previously removed Content-Length',
+        method: 'GET',
+        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
+          outgoing.removeHeader('Content-Length')
+        },
+      },
+      {
+        name: 'disabled default chunking',
+        method: 'GET',
+        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
+          outgoing.useChunkedEncodingByDefault = false
+        },
+      },
+      {
+        name: 'unavailable native length',
+        method: 'GET',
+        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
+          Object.defineProperty(outgoing, '_contentLength', { value: undefined })
+        },
+      },
+      {
+        name: 'already initialized native length',
+        method: 'GET',
+        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
+          Object.defineProperty(outgoing, '_contentLength', { value: 999 })
+        },
+      },
+    ])('preserves explicit length behavior for $name', async ({ method, prepare }) => {
+      const headers = customHeaders ? Object.freeze({ 'content-type': 'text/plain' }) : undefined
+      const listener = getRequestListener(() => new Response('hello', { headers }))
+      const server = createServer((incoming, outgoing) => {
+        prepare(incoming, outgoing)
+        void listener(incoming, outgoing)
+      })
+      const res = await requestServer(server, { path: '/', method })
+      expect(res.status).toBe(200)
+      expect(res.headers.get('content-length')).toBe('5')
+      expect(await res.text()).toBe(method === 'HEAD' ? '' : 'hello')
+    })
+  })
+
+  it('honors strictContentLength for JSON', async () => {
+    const app = new App()
+    app.get('/', (c) => c.json({ message: 'hello' }))
+    const listener = getRequestListener(app.fetch)
+    const server = createServer((incoming, outgoing) => {
+      outgoing.strictContentLength = true
+      void listener(incoming, outgoing)
+    })
+    const res = await requestServer(server, { path: '/' })
+    const text = await res.text()
+    expect(res.status).toBe(200)
+    expect(JSON.parse(text)).toEqual({ message: 'hello' })
+    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(text)))
+  })
+
+  it('preserves the spelling of an explicit Content-Length value', async () => {
+    const headers = Object.freeze({ 'cOnTeNt-LeNgTh': '00005' })
+    const server = createServer(getRequestListener(() => new Response('hello', { headers })))
+    const res = await requestServer(server, { path: '/' })
+    expect(res.headers.get('content-length')).toBe('00005')
+    expect(await res.text()).toBe('hello')
+  })
+
+  it.each([
+    {
+      name: 'an invalid header value',
+      response: () => new Response('hi', { headers: { 'x-bad': 'a\r\nb' } }),
+    },
+    {
+      name: 'an invalid status code with custom headers',
+      response: () => new Response('hi', { status: 1000, headers: { 'x-ok': '1' } }),
+    },
+    {
+      name: 'an invalid status code without custom headers',
+      response: () => new Response('hi', { status: 1000 }),
+    },
+  ])('does not leak a stale length into the 500 response after $name', async ({ response }) => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const server = createServer(getRequestListener(async () => response()))
+    try {
+      server.listen(0, '127.0.0.1')
+      await once(server, 'listening')
+      const { port } = server.address() as AddressInfo
+      // Read the wire response so a stale length cannot truncate the observed body.
+      const raw = await new Promise<string>((resolve, reject) => {
+        const chunks: Buffer[] = []
+        const socket = connectNet(port, '127.0.0.1', () => {
+          socket.write('GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
+        })
+        socket.setTimeout(2000, () => socket.destroy(new Error('Response timed out')))
+        socket.on('data', (chunk) => chunks.push(chunk))
+        socket.on('end', () => resolve(Buffer.concat(chunks).toString('latin1')))
+        socket.on('error', reject)
+      })
+      const separator = raw.indexOf('\r\n\r\n')
+      expect(separator).toBeGreaterThan(0)
+      const head = raw.slice(0, separator)
+      const body = raw.slice(separator + 4)
+      expect(head).toMatch(/^HTTP\/1\.1 500 /)
+      expect(body).toContain('Error: ')
+      const contentLength = head.match(/^content-length: (\d+)$/im)?.[1]
+      if (contentLength !== undefined) {
+        expect(Number(contentLength)).toBe(Buffer.byteLength(body, 'latin1'))
+      } else {
+        expect(head).toMatch(/^transfer-encoding: chunked$/im)
+      }
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()))
+      consoleSpy.mockRestore()
+    }
+  })
+})