acrylblends 0.6.2 → 0.6.4

package/plugins/acryl-router/src/core/helper/streaming/stream.test.ts

@@ -1,128 +0,0 @@
-import { stream } from './index.ts'
-import { Context } from '../../context.ts'
-
-describe('Basic Streaming Helper', () => {
-  const req = new Request('http://localhost/')
-  let c: Context
-  beforeEach(() => {
-    c = new Context(req)
-  })
-
-  it('Check stream Response', async () => {
-    const res = stream(c, async (stream) => {
-      for (let i = 0; i < 3; i++) {
-        await stream.write(new Uint8Array([i]))
-        await stream.sleep(1)
-      }
-    })
-    if (!res.body) {
-      throw new Error('Body is null')
-    }
-    const reader = res.body.getReader()
-    for (let i = 0; i < 3; i++) {
-      const { value } = await reader.read()
-      expect(value).toEqual(new Uint8Array([i]))
-    }
-  })
-
-  it('Check stream Response if aborted by client', async () => {
-    let aborted = false
-    const res = stream(c, async (stream) => {
-      stream.onAbort(() => {
-        aborted = true
-      })
-      for (let i = 0; i < 3; i++) {
-        await stream.write(new Uint8Array([i]))
-        await stream.sleep(1)
-      }
-    })
-    if (!res.body) {
-      throw new Error('Body is null')
-    }
-    const reader = res.body.getReader()
-    const { value } = await reader.read()
-    expect(value).toEqual(new Uint8Array([0]))
-    reader.cancel()
-    expect(aborted).toBeTruthy()
-  })
-
-  it('Check stream Response if aborted by abort signal', async () => {
-    // Emulate an old version of Bun (version 1.1.0) for this specific test case
-    // @ts-expect-error Bun is not typed
-    global.Bun = {
-      version: '1.1.0',
-    }
-    const ac = new AbortController()
-    const req = new Request('http://localhost/', { signal: ac.signal })
-    const c = new Context(req)
-
-    let aborted = false
-    const res = stream(c, async (stream) => {
-      stream.onAbort(() => {
-        aborted = true
-      })
-      for (let i = 0; i < 3; i++) {
-        await stream.write(new Uint8Array([i]))
-        await stream.sleep(1)
-      }
-    })
-    if (!res.body) {
-      throw new Error('Body is null')
-    }
-    const reader = res.body.getReader()
-    const { value } = await reader.read()
-    expect(value).toEqual(new Uint8Array([0]))
-    ac.abort()
-    expect(aborted).toBeTruthy()
-    // @ts-expect-error Bun is not typed
-    delete global.Bun
-  })
-
-  it('Check stream Response if pipe is aborted by abort signal', async () => {
-    // Emulate an old version of Bun (version 1.1.0) for this specific test case
-    // @ts-expect-error Bun is not typed
-    global.Bun = {
-      version: '1.1.0',
-    }
-    const ac = new AbortController()
-    const req = new Request('http://localhost/', { signal: ac.signal })
-    const c = new Context(req)
-
-    let aborted = false
-    const res = stream(c, async (stream) => {
-      stream.onAbort(() => {
-        aborted = true
-      })
-      await stream.pipe(new ReadableStream())
-    })
-    if (!res.body) {
-      throw new Error('Body is null')
-    }
-    const reader = res.body.getReader()
-    const pReading = reader.read()
-    ac.abort()
-    await pReading
-    expect(aborted).toBeTruthy()
-    // @ts-expect-error Bun is not typed
-    delete global.Bun
-  })
-
-  it('Check stream Response if error occurred', async () => {
-    const onError = vi.fn()
-    const res = stream(
-      c,
-      async () => {
-        throw new Error('error')
-      },
-      onError
-    )
-    if (!res.body) {
-      throw new Error('Body is null')
-    }
-    const reader = res.body.getReader()
-    const { value } = await reader.read()
-    expect(value).toBeUndefined()
-    expect(onError).toBeCalledTimes(1)
-    expect(onError).toBeCalledWith(new Error('error'), expect.anything()) // 2nd argument is StreamingApi instance
-  })
-})

package/plugins/acryl-router/src/core/helper/streaming/text.test.ts

@@ -1,34 +0,0 @@
-import { streamText } from './index.ts'
-import { Context } from '../../context.ts'
-
-describe('Text Streaming Helper', () => {
-  const req = new Request('http://localhost/')
-  let c: Context
-  beforeEach(() => {
-    c = new Context(req)
-  })
-
-  it('Check streamText Response', async () => {
-    const res = streamText(c, async (stream) => {
-      for (let i = 0; i < 3; i++) {
-        await stream.write(`${i}`)
-        await stream.sleep(1)
-      }
-    })
-
-    expect(res.status).toBe(200)
-    expect(res.headers.get('content-type')).toMatch(/^text\/plain/)
-    expect(res.headers.get('x-content-type-options')).toBe('nosniff')
-    expect(res.headers.get('transfer-encoding')).toBe('chunked')
-
-    if (!res.body) {
-      throw new Error('Body is null')
-    }
-    const reader = res.body.getReader()
-    const decoder = new TextDecoder()
-    for (let i = 0; i < 3; i++) {
-      const { value } = await reader.read()
-      expect(decoder.decode(value)).toEqual(`${i}`)
-    }
-  })
-})

package/plugins/acryl-router/src/core/helper/testing/index.test.ts

@@ -1,42 +0,0 @@
-import { testClient } from './index.ts'
-import { Acryl } from '../../app.ts'
-
-describe('acryl testClient', () => {
-  it('Should return the correct search result', async () => {
-    const app = new Acryl().get('/search', (c) => c.json({ hello: 'world' }))
-    const res = await testClient(app).search.$get()
-    expect(await res.json()).toEqual({ hello: 'world' })
-  })
-
-  it('Should return the correct environment variables value', async () => {
-    type Bindings = { hello: string }
-    const app = new Acryl<{ Bindings: Bindings }>().get('/search', (c) => {
-      return c.json({ hello: c.env.hello })
-    })
-    const res = await testClient(app, { hello: 'world' }).search.$get()
-    expect(await res.json()).toEqual({ hello: 'world' })
-  })
-
-  it('Should use the passed in headers', async () => {
-    const app = new Acryl().get('/search', (c) => {
-      return c.json({ query: c.req.header('x-query') })
-    })
-    const res = await testClient(app, undefined, undefined, {
-      headers: { 'x-query': 'abc' },
-    }).search.$get()
-    expect(await res.json()).toEqual({ query: 'abc' })
-  })
-
-  it('Should return a correct URL with out throwing an error', async () => {
-    const app = new Acryl().get('/abc', (c) => c.json(0))
-    const url = testClient(app).abc.$url()
-    expect(url.pathname).toBe('/abc')
-  })
-
-  it('Should not throw an error with $ws()', async () => {
-    vi.stubGlobal('WebSocket', class {})
-    const app = new Acryl().get('/ws', (c) => c.text('Fake response of a WebSocket'))
-    // @ts-expect-error $ws is not typed correctly
-    expect(() => testClient(app).ws.$ws()).not.toThrowError()
-  })
-})

package/plugins/acryl-router/src/core/helper/websocket/index.test.ts

@@ -1,124 +0,0 @@
-import type { WSContextInit } from './index.ts'
-import { WSContext, createWSMessageEvent, defineWebSocketHelper } from './index.ts'
-import { Context } from '../../context.ts'
-
-describe('`createWSMessageEvent`', () => {
-  it('Should `createWSMessageEvent` is working for string', () => {
-    const randomString = Math.random().toString()
-    const event = createWSMessageEvent(randomString)
-
-    expect(event.data).toBe(randomString)
-  })
-  it('Should `createWSMessageEvent` type is `message`', () => {
-    const event = createWSMessageEvent('')
-    expect(event.type).toBe('message')
-  })
-})
-describe('defineWebSocketHelper', () => {
-  it('defineWebSocketHelper should work', async () => {
-    const upgradeWebSocket = defineWebSocketHelper(() => {
-      return new Response('Hello World', {
-        status: 200,
-      })
-    })
-    const response = await upgradeWebSocket(() => ({}))(
-      new Context(new Request('http://localhost')),
-      () => Promise.resolve()
-    )
-    expect(response).toBeTruthy()
-    expect((response as Response).status).toBe(200)
-  })
-  it('When response is undefined, should call next()', async () => {
-    const upgradeWebSocket = defineWebSocketHelper(() => {
-      return
-    })
-    const next = vi.fn()
-    await upgradeWebSocket(() => ({}))(new Context(new Request('http://localhost')), next)
-    expect(next).toBeCalled()
-  })
-  it('Use upgradeWebSocket in return', async () => {
-    const upgradeWebSocket = defineWebSocketHelper(() => {
-      return new Response('Hello World', {
-        status: 200,
-      })
-    })
-    const c = new Context(new Request('http://localhost'))
-    const res = await upgradeWebSocket(c, {})
-    expect(res.status).toBe(200)
-  })
-  it('When upgrading failed and use it in handler, it should throw error', async () => {
-    const upgradeWebSocket = defineWebSocketHelper(() => {
-      return
-    })
-    const c = new Context(new Request('http://localhost'))
-    await expect(() => upgradeWebSocket(c, {})).rejects.toThrow()
-  })
-})
-describe('WSContext', () => {
-  it('Should close() works', async () => {
-    type Result = [number | undefined, string | undefined]
-    let ws!: WSContext
-    const promise = new Promise<Result>((resolve) => {
-      ws = new WSContext({
-        close(code, reason) {
-          resolve([code, reason])
-        },
-      } as WSContextInit)
-    })
-    ws.close(0, 'reason')
-    const [code, reason] = await promise
-    expect(code).toBe(0)
-    expect(reason).toBe('reason')
-  })
-  it('Should send() works', async () => {
-    let ws!: WSContext
-    const promise = new Promise<string | ArrayBuffer | Uint8Array<ArrayBuffer>>((resolve) => {
-      ws = new WSContext({
-        send(data: string | ArrayBuffer | Uint8Array<ArrayBuffer>, _options) {
-          resolve(data)
-        },
-      } as WSContextInit)
-    })
-    ws.send('Hello')
-    expect(await promise).toBe('Hello')
-  })
-  it('Should readyState works', () => {
-    const ws = new WSContext({
-      readyState: 0,
-    } as WSContextInit)
-    expect(ws.readyState).toBe(0)
-  })
-  it('Should normalize URL', () => {
-    const stringURLWS = new WSContext({
-      url: 'http://localhost',
-    } as WSContextInit)
-    expect(stringURLWS.url).toBeInstanceOf(URL)
-
-    const urlURLWS = new WSContext({
-      url: new URL('http://localhost'),
-    } as WSContextInit)
-    expect(urlURLWS.url).toBeInstanceOf(URL)
-
-    const nullURLWS = new WSContext({
-      url: undefined,
-    } as WSContextInit)
-    expect(nullURLWS.url).toBeNull()
-  })
-  it('Should normalize message in send()', () => {
-    let data: string | ArrayBuffer | Uint8Array | null = null
-    const wsContext = new WSContext({
-      send(received, _options) {
-        data = received
-      },
-    } as WSContextInit)
-
-    wsContext.send('string')
-    expect(data).toBe('string')
-
-    wsContext.send(new ArrayBuffer(16))
-    expect(data).toBeInstanceOf(ArrayBuffer)
-
-    wsContext.send(new Uint8Array(16))
-    expect(data).toBeInstanceOf(Uint8Array)
-  })
-})

package/plugins/acryl-router/src/core/http-exception.test.ts

@@ -1,45 +0,0 @@
-import { HTTPException } from './http-exception.ts'
-
-describe('HTTPException', () => {
-  it('Should be 401 HTTP exception object', async () => {
-    // We should throw an exception if is not authorized
-    // because next handlers should not be fired.
-    const exception = new HTTPException(401, {
-      message: 'Unauthorized',
-    })
-    const res = exception.getResponse()
-
-    expect(res.status).toBe(401)
-    expect(await res.text()).toBe('Unauthorized')
-    expect(exception.status).toBe(401)
-    expect(exception.message).toBe('Unauthorized')
-  })
-
-  it('Should be accessible to the object causing the exception', async () => {
-    // We should pass the cause of the error to the cause option
-    // because it makes debugging easier.
-    const error = new Error('Server Error')
-    const exception = new HTTPException(500, {
-      message: 'Internal Server Error',
-      cause: error,
-    })
-    const res = exception.getResponse()
-
-    expect(res.status).toBe(500)
-    expect(await res.text()).toBe('Internal Server Error')
-    expect(exception.status).toBe(500)
-    expect(exception.message).toBe('Internal Server Error')
-    expect(exception.cause).toBe(error)
-  })
-
-  it('Should prioritize the status code over the code in the response', async () => {
-    const exception = new HTTPException(400, {
-      res: new Response('An exception', {
-        status: 200,
-      }),
-    })
-    const res = exception.getResponse()
-    expect(res.status).toBe(400)
-    expect(await res.text()).toBe('An exception')
-  })
-})