acrylblends 0.6.3 → 0.7.0

package/plugins/acryl-router/src/core/request.test.ts

@@ -1,751 +0,0 @@
-import { HTTPException } from './http-exception.ts'
-import { cloneRawRequest, AcrylRequest } from './request.ts'
-import type { RouterRoute } from './types.ts'
-
-type RecursiveRecord<K extends string, T> = {
-  [key in K]: T | RecursiveRecord<K, T>
-}
-
-describe('Query', () => {
-  test('req.query() and req.queries()', () => {
-    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
-    const req = new AcrylRequest(rawRequest)
-
-    const page = req.query('page')
-    expect(page).not.toBeUndefined()
-    expect(page).toBe('2')
-
-    const q = req.query('q')
-    expect(q).toBeUndefined()
-
-    const tags = req.queries('tag')
-    expect(tags).not.toBeUndefined()
-    expect(tags).toEqual(['A', 'B'])
-
-    const q2 = req.queries('q2')
-    expect(q2).toBeUndefined()
-  })
-
-  test('decode special chars', () => {
-    const rawRequest = new Request('http://localhost?mail=framework%40acryl.dev&tag=%401&tag=%402')
-    const req = new AcrylRequest(rawRequest)
-
-    const mail = req.query('mail')
-    expect(mail).toBe('framework@acryl.dev')
-
-    const tags = req.queries('tag')
-    expect(tags).toEqual(['@1', '@2'])
-  })
-})
-
-describe('Param', () => {
-  test('req.param() on an unmatched request', () => {
-    const req = new AcrylRequest(new Request('http://localhost/'))
-
-    expect(req.param('id')).toBeUndefined()
-    expect(req.param()).toEqual({})
-  })
-
-  test('req.param() should return empty string for zero-length match', () => {
-    // Simulate a route like '/:remaining{.*}' matching '/'
-    const rawRequest = new Request('http://localhost/')
-    const req = new AcrylRequest<'/:remaining{.*}'>(rawRequest, '/', [
-      [[[undefined, {} as RouterRoute], { remaining: 0 }]],
-      [''], // ParamStash with empty string for remaining
-    ])
-
-    // Single param access should be empty string, not undefined
-    expect(req.param('remaining')).toBe('')
-
-    // All params should include key with empty string value
-    const all = req.param()
-    expect(all).toEqual({ remaining: '' })
-  })
-  test('req.param() with ParamStash', () => {
-    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
-    const req = new AcrylRequest<'/:id/:name'>(rawRequest, '/123/key', [
-      [
-        [[undefined, {} as RouterRoute], { id: 0 }],
-        [[undefined, {} as RouterRoute], { id: 0, name: 1 }],
-      ],
-      ['123', 'key'],
-    ])
-
-    expect(req.param('id')).toBe('123')
-    expect(req.param('name')).toBe(undefined)
-
-    req.routeIndex = 1
-    expect(req.param('id')).toBe('123')
-    expect(req.param('name')).toBe('key')
-  })
-
-  test('req.param() without ParamStash', () => {
-    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
-    const req = new AcrylRequest<'/:id/:name'>(rawRequest, '/123/key', [
-      [
-        [[undefined, {} as RouterRoute], { id: '123' }],
-        [[undefined, {} as RouterRoute], { id: '456', name: 'key' }],
-      ],
-    ])
-
-    expect(req.param('id')).toBe('123')
-    expect(req.param('name')).toBe(undefined)
-
-    req.routeIndex = 1
-    expect(req.param('id')).toBe('456')
-    expect(req.param('name')).toBe('key')
-  })
-
-  test('req.param() returns empty string for missing param', () => {
-    const rawRequest = new Request('http://localhost')
-    const req = new AcrylRequest<'/:remaining'>(rawRequest, '/', [
-      [[[undefined, {} as RouterRoute], { remaining: 0 }]],
-      [''],
-    ])
-    expect(req.param('remaining')).toBe('')
-  })
-
-  test('req.param() without argument returns object with empty string for missing param', () => {
-    const rawRequest = new Request('http://localhost')
-    const req = new AcrylRequest<'/:remaining'>(rawRequest, '/', [
-      [[[undefined, {} as RouterRoute], { remaining: 0 }]],
-      [''],
-    ])
-    expect(req.param()).toEqual({ remaining: '' })
-  })
-
-  describe('Type', () => {
-    it('param() returns string | undefined when P is any (middleware context)', () => {
-      // When middleware uses Context without an explicit path type, P defaults to any.
-      // param(key) should return string | undefined, not string.
-      const rawRequest = new Request('http://localhost/users/123')
-      const req = new AcrylRequest<any>(rawRequest, '/users/123', [
-        [[[undefined, {} as RouterRoute], { id: '123' }]],
-      ])
-      expectTypeOf(req.param('id')).toEqualTypeOf<string | undefined>()
-    })
-
-    it('param() returns string when P is a known route string', () => {
-      // When P is a concrete route, named params should still return string (non-optional).
-      const rawRequest = new Request('http://localhost/123')
-      const req = new AcrylRequest<'/:id'>(rawRequest, '/123', [
-        [[[undefined, {} as RouterRoute], { id: '123' }]],
-      ])
-      expectTypeOf(req.param('id')).toEqualTypeOf<string>()
-    })
-  })
-})
-
-describe('matchedRoutes', () => {
-  test('req.routePath', () => {
-    const handlerA = () => {}
-    const handlerB = () => {}
-    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
-    const req = new AcrylRequest<'/:id/:name'>(rawRequest, '/123/key', [
-      [
-        [
-          [handlerA, { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' }],
-          { id: '123' },
-        ],
-        [
-          [handlerA, { basePath: '/', handler: handlerB, method: 'GET', path: '/:id/:name' }],
-          { id: '456', name: 'key' },
-        ],
-      ],
-    ])
-
-    expect(req.matchedRoutes).toEqual([
-      { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' },
-      { basePath: '/', handler: handlerB, method: 'GET', path: '/:id/:name' },
-    ])
-  })
-})
-
-describe('routePath', () => {
-  test('req.routePath', () => {
-    const handlerA = () => {}
-    const handlerB = () => {}
-    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
-    const req = new AcrylRequest<'/:id/:name'>(rawRequest, '/123/key', [
-      [
-        [
-          [handlerA, { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' }],
-          { id: '123' },
-        ],
-        [
-          [handlerA, { basePath: '/', handler: handlerB, method: 'GET', path: '/:id/:name' }],
-          { id: '456', name: 'key' },
-        ],
-      ],
-    ])
-
-    expect(req.routePath).toBe('/:id')
-
-    req.routeIndex = 1
-    expect(req.routePath).toBe('/:id/:name')
-  })
-})
-
-describe('req.addValidatedData() and req.data()', () => {
-  const rawRequest = new Request('http://localhost')
-
-  const payload = {
-    title: 'hello',
-    author: {
-      name: 'young man',
-      age: 20,
-    },
-  }
-
-  test('add data - json', () => {
-    const req = new AcrylRequest<'/', { json: typeof payload }>(rawRequest)
-    req.addValidatedData('json', payload)
-    const data = req.valid('json')
-    expect(data).toEqual(payload)
-  })
-
-  test('replace data - json', () => {
-    const req = new AcrylRequest<'/', { json: typeof payload }>(rawRequest)
-    req.addValidatedData('json', payload)
-    req.addValidatedData('json', {
-      tag: ['sport', 'music'],
-      author: {
-        tall: 170,
-      },
-    })
-    const data = req.valid('json')
-    expect(data).toEqual({
-      author: {
-        tall: 170,
-      },
-      tag: ['sport', 'music'],
-    })
-  })
-})
-
-describe('headers', () => {
-  test('empty string is a valid header value', () => {
-    const req = new AcrylRequest(new Request('http://localhost', { headers: { foo: '' } }))
-    const foo = req.header('foo')
-    expect(foo).toEqual('')
-  })
-
-  test('Keys of the arguments for req.header() are not case-sensitive', () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        headers: {
-          'Content-Type': 'application/json',
-          apikey: 'abc',
-          lowercase: 'lowercase value',
-        },
-      })
-    )
-    expect(req.header('Content-Type')).toBe('application/json')
-    expect(req.header('ApiKey')).toBe('abc')
-  })
-
-  test('req.header() is not affected by a `__proto__` header name', () => {
-    const req = new AcrylRequest(new Request('http://localhost', { headers: { __proto__: 'evil' } }))
-    const headers = req.header()
-    expect(Object.getPrototypeOf(headers)).toBeNull()
-  })
-})
-
-const text = '{"foo":"bar"}'
-const json = { foo: 'bar' }
-const buffer = new TextEncoder().encode('{"foo":"bar"}').buffer
-
-describe('Body methods with caching', () => {
-  test('req.text()', async () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: text,
-      })
-    )
-    expect(await req.text()).toEqual(text)
-    expect(await req.json()).toEqual(json)
-    expect(await req.arrayBuffer()).toEqual(buffer)
-    expect(await req.bytes()).toEqual(new Uint8Array(buffer))
-    expect(await req.blob()).toEqual(
-      new Blob([text], {
-        type: 'text/plain;charset=utf-8',
-      })
-    )
-  })
-
-  test('req.json()', async () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: '{"foo":"bar"}',
-      })
-    )
-    expect(await req.json()).toEqual(json)
-    expect(await req.text()).toEqual(text)
-    expect(await req.arrayBuffer()).toEqual(buffer)
-    expect(await req.bytes()).toEqual(new Uint8Array(buffer))
-    expect(await req.blob()).toEqual(
-      new Blob([text], {
-        type: 'text/plain;charset=utf-8',
-      })
-    )
-  })
-
-  test('req.json() should keep the content as is', async () => {
-    const text = '{ "foo" : "bar" }'
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: text,
-      })
-    )
-    expect(await req.json()).toEqual(JSON.parse(text))
-    expect(await req.text()).toEqual(text)
-  })
-
-  test('req.arrayBuffer()', async () => {
-    const buffer = new TextEncoder().encode('{"foo":"bar"}').buffer
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: buffer,
-      })
-    )
-    expect(await req.arrayBuffer()).toEqual(buffer)
-    expect(await req.text()).toEqual(text)
-    expect(await req.json()).toEqual(json)
-    expect(await req.bytes()).toEqual(new Uint8Array(buffer))
-    expect(await req.blob()).toEqual(
-      new Blob([text], {
-        type: '',
-      })
-    )
-  })
-
-  test('req.bytes()', async () => {
-    const bytes = new TextEncoder().encode('{"foo":"bar"}')
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: bytes,
-      })
-    )
-    const result = await req.bytes()
-    expect(result).toBeInstanceOf(Uint8Array)
-    expect(result).toEqual(bytes)
-    expect(await req.text()).toEqual(text)
-    expect(await req.json()).toEqual(json)
-    expect(await req.arrayBuffer()).toEqual(buffer)
-    expect(await req.blob()).toEqual(
-      new Blob([text], {
-        type: '',
-      })
-    )
-  })
-
-  test('req.blob()', async () => {
-    const blob = new Blob(['{"foo":"bar"}'], {
-      type: 'application/json',
-    })
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: blob,
-      })
-    )
-    expect(await req.blob()).toEqual(blob)
-    expect(await req.text()).toEqual(text)
-    expect(await req.json()).toEqual(json)
-    expect(await req.arrayBuffer()).toEqual(buffer)
-    expect(await req.bytes()).toEqual(new Uint8Array(buffer))
-  })
-
-  test('req.formData()', async () => {
-    const data = new FormData()
-    data.append('foo', 'bar')
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: data,
-      })
-    )
-    expect((await req.formData()).get('foo')).toBe('bar')
-    expect(async () => await req.text()).not.toThrow()
-    expect(async () => await req.arrayBuffer()).not.toThrow()
-    expect(async () => await req.bytes()).not.toThrow()
-    expect(async () => await req.blob()).not.toThrow()
-  })
-
-  describe('formData() after another representation has been cached', () => {
-    const urlencoded = 'application/x-www-form-urlencoded'
-    const body = 'foo=bar&baz=qux'
-
-    for (const first of ['text', 'arrayBuffer', 'bytes', 'blob'] as const) {
-      test(`req.formData() after req.${first}()`, async () => {
-        const req = new AcrylRequest(
-          new Request('http://localhost', {
-            method: 'POST',
-            headers: { 'Content-Type': urlencoded },
-            body,
-          })
-        )
-        await req[first]()
-        const formData = await req.formData()
-        expect(formData.get('foo')).toBe('bar')
-        expect(formData.get('baz')).toBe('qux')
-      })
-    }
-
-    test('req.formData() after req.text() for multipart/form-data', async () => {
-      const boundary = '----acryl-test-boundary'
-      const multipart =
-        `--${boundary}\r\n` +
-        'Content-Disposition: form-data; name="foo"\r\n\r\n' +
-        'bar\r\n' +
-        `--${boundary}--\r\n`
-      const req = new AcrylRequest(
-        new Request('http://localhost', {
-          method: 'POST',
-          headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}` },
-          body: multipart,
-        })
-      )
-      await req.text()
-      expect((await req.formData()).get('foo')).toBe('bar')
-    })
-
-    test('the cached representation is still returned unchanged', async () => {
-      const req = new AcrylRequest(
-        new Request('http://localhost', {
-          method: 'POST',
-          headers: { 'Content-Type': urlencoded },
-          body,
-        })
-      )
-      expect(await req.text()).toBe(body)
-      expect(await req.text()).toBe(body)
-      expect(await req.arrayBuffer()).toEqual(new TextEncoder().encode(body).buffer)
-    })
-  })
-
-  describe('req.parseBody()', async () => {
-    it('should parse form data', async () => {
-      const data = new FormData()
-      data.append('foo', 'bar')
-      const req = new AcrylRequest(
-        new Request('http://localhost', {
-          method: 'POST',
-          body: data,
-        })
-      )
-      expect((await req.parseBody())['foo']).toBe('bar')
-      expect(async () => await req.text()).not.toThrow()
-      expect(async () => await req.arrayBuffer()).not.toThrow()
-      expect(async () => await req.bytes()).not.toThrow()
-      expect(async () => await req.blob()).not.toThrow()
-    })
-
-    it('should parse form data even if formData() is called before parseBody()', async () => {
-      const data = new FormData()
-      data.append('foo', 'bar')
-      data.append('file', new File(['hello'], 't.txt', { type: 'text/plain' }))
-      const req = new AcrylRequest(
-        new Request('http://localhost', {
-          method: 'POST',
-          body: data,
-        })
-      )
-      await req.formData()
-      const body = await req.parseBody()
-      expect(body['foo']).toBe('bar')
-      expect(body['file']).toBeInstanceOf(File)
-    })
-
-    describe('should not break body methods after parseBody() with non-form content-type', () => {
-      const createReq = () =>
-        new AcrylRequest(
-          new Request('http://localhost', {
-            method: 'POST',
-            body: JSON.stringify({ event: 'push' }),
-            headers: { 'Content-Type': 'application/json' },
-          })
-        )
-
-      it('text()', async () => {
-        const req = createReq()
-        await req.parseBody()
-        expect(await req.text()).toBe(JSON.stringify({ event: 'push' }))
-      })
-
-      it('json()', async () => {
-        const req = createReq()
-        await req.parseBody()
-        expect(await req.json()).toEqual({ event: 'push' })
-      })
-
-      it('arrayBuffer()', async () => {
-        const req = createReq()
-        await req.parseBody()
-        expect(await req.arrayBuffer()).toBeInstanceOf(ArrayBuffer)
-      })
-
-      it('bytes()', async () => {
-        const req = createReq()
-        await req.parseBody()
-        expect(await req.bytes()).toBeInstanceOf(Uint8Array)
-      })
-
-      it('blob()', async () => {
-        const req = createReq()
-        await req.parseBody()
-        expect(await req.blob()).toBeInstanceOf(Blob)
-      })
-
-      it('formData()', async () => {
-        const req = createReq()
-        await req.parseBody()
-        // application/json is not a valid formData content-type, so this should throw
-        await expect(req.formData()).rejects.toThrow()
-      })
-    })
-
-    describe('Return type', () => {
-      let req: AcrylRequest
-      beforeEach(() => {
-        const data = new FormData()
-        data.append('foo', 'bar')
-        req = new AcrylRequest(
-          new Request('http://localhost', {
-            method: 'POST',
-            body: data,
-          })
-        )
-      })
-
-      it('without options', async () => {
-        expectTypeOf((await req.parseBody())['key']).toEqualTypeOf<string | File>()
-      })
-
-      it('{all: true}', async () => {
-        expectTypeOf((await req.parseBody({ all: true }))['key']).toEqualTypeOf<
-          string | File | (string | File)[]
-        >()
-      })
-
-      it('{dot: true}', async () => {
-        expectTypeOf((await req.parseBody({ dot: true }))['key']).toEqualTypeOf<
-          string | File | RecursiveRecord<string, string | File>
-        >()
-      })
-
-      it('{all: true, dot: true}', async () => {
-        expectTypeOf((await req.parseBody({ all: true, dot: true }))['key']).toEqualTypeOf<
-          | string
-          | File
-          | (string | File)[]
-          | RecursiveRecord<string, string | File | (string | File)[]>
-        >()
-      })
-
-      it('specify return type explicitly', async () => {
-        expectTypeOf(
-          await req.parseBody<{ key1: string; key2: string }>({ all: true, dot: true })
-        ).toEqualTypeOf<{ key1: string; key2: string }>()
-      })
-    })
-  })
-})
-
-describe('cloneRawRequest', () => {
-  test('clones unconsumed request object', async () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'X-Custom-Header': 'custom-value',
-        },
-        body: text,
-        cache: 'no-cache',
-        credentials: 'include',
-        integrity: 'sha256-test',
-        mode: 'cors',
-        redirect: 'follow',
-        referrer: 'http://example.com',
-        referrerPolicy: 'origin',
-      })
-    )
-
-    const clonedReq = await cloneRawRequest(req)
-
-    expect(clonedReq.method).toBe('POST')
-    expect(clonedReq.url).toBe('http://localhost/')
-    expect(await clonedReq.text()).toBe(text)
-    expect(clonedReq.headers.get('Content-Type')).toBe('application/json')
-    expect(clonedReq.headers.get('X-Custom-Header')).toBe('custom-value')
-    expect(clonedReq.cache).toBe('no-cache')
-    expect(clonedReq.credentials).toBe('include')
-    expect(clonedReq.integrity).toBe('sha256-test')
-    expect(clonedReq.mode).toBe('cors')
-    expect(clonedReq.redirect).toBe('follow')
-    expect(clonedReq.referrer).toBe('http://example.com/')
-    expect(clonedReq.referrerPolicy).toBe('origin')
-    expect(req.raw, 'cloned request should be a different object reference').not.toBe(clonedReq)
-    expect(req.raw, 'cloned request should contain the same properties').toMatchObject(clonedReq)
-  })
-
-  test('clones consumed request object', async () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        headers: {
-          Authorization: 'Bearer token123',
-        },
-        body: text,
-        mode: 'same-origin',
-        credentials: 'same-origin',
-      })
-    )
-    await req.json()
-
-    const clonedReq = await cloneRawRequest(req)
-
-    expect(clonedReq.method).toBe('POST')
-    expect(clonedReq.url).toBe('http://localhost/')
-    expect(await clonedReq.json()).toEqual(json)
-    expect(clonedReq.headers.get('Authorization')).toBe('Bearer token123')
-    expect(clonedReq.mode).toBe('same-origin')
-    expect(clonedReq.credentials).toBe('same-origin')
-    expect(req.raw, 'cloned request should be a different object reference').not.toBe(clonedReq)
-    expect(req.raw, 'cloned request should contain the same properties').toMatchObject(clonedReq)
-  })
-
-  test('clones consumed multipart request with a matching boundary', async () => {
-    const data = new FormData()
-    data.append('foo', 'bar')
-    data.append('file', new File(['hello'], 't.txt', { type: 'text/plain' }))
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        body: data,
-      })
-    )
-    await req.formData()
-
-    const clonedReq = await cloneRawRequest(req)
-
-    const contentType = clonedReq.headers.get('Content-Type') ?? ''
-    const boundary = contentType.split('boundary=')[1]
-    const bodyText = await clonedReq.clone().text()
-    expect(bodyText.startsWith(`--${boundary}`)).toBe(true)
-
-    const formData = await clonedReq.formData()
-    expect(formData.get('foo')).toBe('bar')
-    expect(formData.get('file')).toBeInstanceOf(File)
-  })
-
-  test('drops stale content length when cloning consumed multipart request', async () => {
-    const boundary = 'boundary'
-    const body = [
-      `--${boundary}`,
-      'Content-Disposition: form-data; name="foo"',
-      '',
-      'bar',
-      `--${boundary}--`,
-      '',
-    ].join('\r\n')
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        headers: {
-          'Content-Type': `multipart/form-data; boundary=${boundary}`,
-          'Content-Length': new TextEncoder().encode(body).byteLength.toString(),
-        },
-        body,
-      })
-    )
-    await req.formData()
-
-    const clonedReq = await cloneRawRequest(req)
-
-    expect(clonedReq.headers.has('Content-Length')).toBe(false)
-    expect((await clonedReq.formData()).get('foo')).toBe('bar')
-  })
-
-  test('clones request when external code populated bodyCache.json', async () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ foo: 'bar' }),
-      })
-    )
-    await req.raw.json()
-    req.bodyCache.json = Promise.resolve({ foo: 'bar' })
-
-    const clonedReq = await cloneRawRequest(req)
-
-    expect(await clonedReq.json()).toEqual({ foo: 'bar' })
-  })
-
-  test('clones GET request without body', async () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'GET',
-        headers: {
-          'User-Agent': 'test-agent',
-        },
-        cache: 'default',
-        redirect: 'manual',
-        referrerPolicy: 'no-referrer',
-      })
-    )
-
-    const clonedReq = await cloneRawRequest(req)
-
-    expect(clonedReq.method).toBe('GET')
-    expect(clonedReq.url).toBe('http://localhost/')
-    expect(clonedReq.headers.get('User-Agent')).toBe('test-agent')
-    expect(clonedReq.cache).toBe('default')
-    expect(clonedReq.redirect).toBe('manual')
-    expect(clonedReq.referrerPolicy).toBe('no-referrer')
-    expect(req.raw, 'cloned request should be a different object reference').not.toBe(clonedReq)
-    expect(req.raw, 'cloned request should contain the same properties').toMatchObject(clonedReq)
-  })
-
-  test('clones request when raw body was consumed directly without AcrylRequest methods', async () => {
-    const req = new AcrylRequest(
-      new Request('http://localhost', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: text,
-      })
-    )
-
-    // Consume the raw request body directly, bypassing AcrylRequest methods
-    // This means bodyCache will be empty
-    await req.raw.text()
-
-    expect(req.raw.bodyUsed).toBe(true)
-    expect(Object.keys(req.bodyCache).length).toBe(0)
-
-    let error: HTTPException | undefined = undefined
-    try {
-      await cloneRawRequest(req)
-    } catch (e) {
-      expect(e).toBeInstanceOf(HTTPException)
-      error = e as HTTPException
-    }
-
-    expect(error).not.toBeUndefined()
-    expect((error as HTTPException).status).toBe(500)
-    expect((error as HTTPException).message).toContain(
-      'Cannot clone request: body was already consumed and not cached'
-    )
-  })
-})