acrylblends 0.6.3 → 0.7.0

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')
-  })
-})

package/plugins/acryl-router/src/core/jsx/base.test.tsx

@@ -1,97 +0,0 @@
-/** @jsxImportSource ./ */
-
-import type { HtmlEscapedString } from '../utils/html.ts'
-import type { Child, JSXNode } from './base.ts'
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { cloneElement, jsx, Fragment } from './base.ts'
-
-describe('cloneElement', () => {
-  it('should clone an element with new props', () => {
-    const element = <div className='original'>Hello</div>
-    const clonedElement = cloneElement(element, { className: 'cloned' })
-    expect((clonedElement as unknown as JSXNode).props.className).toBe('cloned')
-    expect((clonedElement as unknown as JSXNode).props.children).toBe('Hello')
-  })
-
-  it('should clone a children element', () => {
-    const fnElement = ({ message }: { message: string }) => <div>{message}</div>
-    const element = fnElement({ message: 'Hello' })
-    const clonedElement = cloneElement(element, {})
-    expect(element.toString()).toBe('<div>Hello</div>')
-    expect(clonedElement.toString()).toBe('<div>Hello</div>')
-  })
-
-  it('should clone an element with new children', () => {
-    const fnElement = ({ message }: { message: string }) => <div>{message}</div>
-    const element = fnElement({ message: 'Hello' })
-    const clonedElement = cloneElement(element, {}, 'World')
-    expect(element.toString()).toBe('<div>Hello</div>')
-    expect(clonedElement.toString()).toBe('<div>World</div>')
-  })
-
-  it('should self-close a wrapped empty tag', () => {
-    const Hr = ({ ...props }) => <hr {...props} />
-    const element = <Hr />
-    expect(element.toString()).toBe('<hr/>')
-  })
-
-  it('should preserve self-closing empty tag when cloned', () => {
-    const element = <img src='foo.png' />
-    const clonedElement = cloneElement(element, { alt: 'bar' })
-    expect(element.toString()).toBe('<img src="foo.png"/>')
-    expect(clonedElement.toString()).toBe('<img src="foo.png" alt="bar"/>')
-  })
-
-  it('should clone an element with array children', () => {
-    const element = (
-      <div>
-        <span>1</span>
-        <span>2</span>
-      </div>
-    )
-    const clonedElement = cloneElement(element, { className: 'cloned' })
-    expect(clonedElement.toString()).toBe('<div class="cloned"><span>1</span><span>2</span></div>')
-  })
-})
-
-describe('createElement', () => {
-  it('should accept a component that returns a JSXNode', () => {
-    const Partial = ({ name }: { name: string }) => jsx('div', { 'x-partial': name }, name)
-
-    expect((<Partial name='foo' />).toString()).toBe('<div x-partial="foo">foo</div>')
-  })
-
-  it('should preserve the SVG element shape', () => {
-    const ref = { current: null }
-    const element = jsx('svg', { ref }) as unknown as JSXNode
-    expect(element.tag).toBe('svg')
-    expect(element.type).toBe('svg')
-    expect(element.ref).toBe(ref)
-  })
-
-  it('should accept a Child-typed value as a child', () => {
-    const child: Child = <span>inner</span>
-    const element = jsx('div', null, child) as unknown as JSXNode
-    expect(element.toString()).toBe('<div><span>inner</span></div>')
-  })
-
-  it('should escape a string returned by an asynchronous component', async () => {
-    const Async = async () => '<img src=x onerror=alert(1)>' as unknown as HtmlEscapedString
-
-    expect(
-      String(
-        await (
-          <div>
-            <Async />
-          </div>
-        ).toString()
-      )
-    ).toBe('<div>&lt;img src=x onerror=alert(1)&gt;</div>')
-  })
-
-  it('should omit an unsupported object child', () => {
-    const object = { toString: () => 'plain-text' }
-
-    expect((<div>{object as never}</div>).toString()).toBe('<div></div>')
-  })
-})

package/plugins/acryl-router/src/core/jsx/children.test.ts

@@ -1,52 +0,0 @@
-import { createElement } from './index.ts'
-import { Children } from './children.ts'
-
-describe('map', () => {
-  it('should map children', () => {
-    const element = createElement('div', null, 1, 2, 3)
-    const result = Children.map(element.children, (child) => (child as number) * 2)
-    expect(result).toEqual([2, 4, 6])
-  })
-})
-
-describe('forEach', () => {
-  it('should iterate children', () => {
-    const element = createElement('div', null, 1, 2, 3)
-    const result: number[] = []
-    Children.forEach(element.children, (child) => {
-      result.push(child as number)
-    })
-    expect(result).toEqual([1, 2, 3])
-  })
-})
-
-describe('count', () => {
-  it('should count children', () => {
-    const element = createElement('div', null, 1, 2, 3)
-    const result = Children.count(element.children)
-    expect(result).toBe(3)
-  })
-})
-
-describe('only', () => {
-  it('should return the only child', () => {
-    const element = createElement('div', null, 1)
-    const result = Children.only(element.children)
-    expect(result).toBe(1)
-  })
-
-  it('should throw an error if there are multiple children', () => {
-    const element = createElement('div', null, 1, 2)
-    expect(() => Children.only(element.children)).toThrowError(
-      'Children.only() expects only one child'
-    )
-  })
-})
-
-describe('toArray', () => {
-  it('should convert children to an array', () => {
-    const element = createElement('div', null, 1, 2, 3)
-    const result = Children.toArray(element.children)
-    expect(result).toEqual([1, 2, 3])
-  })
-})