acrylblends 0.6.2 → 0.6.4

package/plugins/acryl-router/src/core/utils/concurrent.test.ts

@@ -1,69 +0,0 @@
-import { createPool } from './concurrent.ts'
-
-describe('concurrent execution', () => {
-  test.each`
-    concurrency | count
-    ${1}        | ${10}
-    ${10}       | ${10}
-    ${100}      | ${10}
-    ${Infinity} | ${2000}
-  `('concurrency $concurrency, count $count', async ({ concurrency, count }) => {
-    const running = new Set()
-
-    const pool = createPool({ concurrency })
-    let resolve: (() => void) | undefined
-    const promise = new Promise<void>((r) => {
-      resolve = r
-    })
-    const fn = async (i: number) => {
-      if (running.size > concurrency) {
-        throw new Error('concurrency exceeded')
-      }
-
-      running.add(i)
-      await promise
-      running.delete(i)
-      return i
-    }
-
-    const jobs = new Array(count).fill(0).map((_, i) => () => fn(i))
-    const expectedResults = new Array(count).fill(0).map((_, i) => i)
-    const resultPromises = jobs.map((job) => pool.run(job))
-
-    expect(running.size).toBe(Math.min(concurrency, count))
-    resolve?.()
-    const results = await Promise.all(resultPromises)
-    expect(running.size).toBe(0)
-    expect(results).toEqual(expectedResults)
-  })
-
-  describe('with interval', () => {
-    test.each`
-      concurrency | interval
-      ${1}        | ${10}
-      ${2}        | ${10}
-    `('concurrency $concurrency, interval $interval', async ({ concurrency, interval }) => {
-      const workingTimeQueue: number[] = []
-      const pool = createPool({ concurrency, interval })
-      const fn = async (i: number) => {
-        const now = Date.now()
-        if (workingTimeQueue.length >= concurrency) {
-          const last = workingTimeQueue.shift()
-          // Not so accurate, -1 ms is acceptable
-          if (last && now - last < interval - 1) {
-            throw new Error('interval violated')
-          }
-        }
-        workingTimeQueue.push(now)
-        return i
-      }
-
-      const jobs = new Array(10).fill(0).map((_, i) => () => fn(i))
-      const expectedResults = new Array(10).fill(0).map((_, i) => i)
-      const resultPromises = jobs.map((job) => pool.run(job))
-
-      const results = await Promise.all(resultPromises)
-      expect(results).toEqual(expectedResults)
-    })
-  })
-})

package/plugins/acryl-router/src/core/utils/cookie.test.ts

@@ -1,460 +0,0 @@
-import type { Cookie, SignedCookie } from './cookie.ts'
-import { parse, parseSigned, serialize, serializeSigned } from './cookie.ts'
-
-describe('Parse cookie', () => {
-  it('Should parse cookies', () => {
-    const cookieString = 'yummy_cookie=choco; tasty_cookie = strawberry '
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-  })
-
-  it('Should trim only SP and HTAB around cookie pairs', () => {
-    const cookieString = '\tyummy_cookie=choco;\t tasty_cookie = strawberry \t'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-  })
-
-  it('Should parse quoted cookie values', () => {
-    const cookieString =
-      'yummy_cookie="choco"; tasty_cookie = " strawberry " ; best_cookie="%20sugar%20";'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBe(' strawberry ')
-    expect(cookie['best_cookie']).toBe(' sugar ')
-  })
-
-  it('Should not throw a URIError when parsing an invalid string', () => {
-    const cookieString = 'yummy_cookie="choco%2";'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('choco%2')
-  })
-
-  it('Should parse empty cookies', () => {
-    const cookie: Cookie = parse('')
-    expect(Object.keys(cookie).length).toBe(0)
-  })
-
-  it('Should parse one cookie specified by name', () => {
-    const cookieString = 'yummy_cookie=choco; tasty_cookie = strawberry '
-    const cookie: Cookie = parse(cookieString, 'yummy_cookie')
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBeUndefined()
-  })
-
-  it('Should parse one cookie specified by name even if it is not found', () => {
-    const cookieString = 'yummy_cookie=choco; tasty_cookie = strawberry '
-    const cookie: Cookie = parse(cookieString, 'no_such_cookie')
-    expect(cookie['yummy_cookie']).toBeUndefined()
-    expect(cookie['tasty_cookie']).toBeUndefined()
-    expect(cookie['no_such_cookie']).toBeUndefined()
-  })
-
-  it('Should parse cookies with no value', () => {
-    const cookieString = 'yummy_cookie=; tasty_cookie = ; best_cookie= ; last_cookie=""'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('')
-    expect(cookie['tasty_cookie']).toBe('')
-    expect(cookie['best_cookie']).toBe('')
-    expect(cookie['last_cookie']).toBe('')
-  })
-
-  it('Should parse cookies but not process signed cookies', () => {
-    // also contains another cookie with a '.' in its value to test it is not misinterpreted as signed cookie
-    const cookieString =
-      'yummy_cookie=choco; tasty_cookie = strawberry.I9qAeGQOvWjCEJgRPmrw90JjYpnnX2C9zoOiGSxh1Ig%3D; great_cookie=rating3.5; best_cookie=sugar.valueShapedLikeASignatureButIsNotASignature%3D'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBe('strawberry.I9qAeGQOvWjCEJgRPmrw90JjYpnnX2C9zoOiGSxh1Ig=')
-    expect(cookie['great_cookie']).toBe('rating3.5')
-    expect(cookie['best_cookie']).toBe('sugar.valueShapedLikeASignatureButIsNotASignature=')
-  })
-
-  it('Should ignore invalid cookie names', () => {
-    const cookieString = 'yummy_cookie=choco; tasty cookie=strawberry; best_cookie\\=sugar; =ng'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty cookie']).toBeUndefined()
-    expect(cookie['best_cookie\\']).toBeUndefined()
-    expect(cookie['']).toBeUndefined()
-  })
-
-  it('Should parse cookies whose names are not RFC 6265 tokens', () => {
-    const cookieString =
-      'paraglide:lang=en; CognitoIdentityServiceProvider.abc.user@example.com.idToken=token; round(brackets)=ok; square[brackets]=ok; curly{brackets}=ok'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['paraglide:lang']).toBe('en')
-    expect(cookie['CognitoIdentityServiceProvider.abc.user@example.com.idToken']).toBe('token')
-    expect(cookie['round(brackets)']).toBe('ok')
-    expect(cookie['square[brackets]']).toBe('ok')
-    expect(cookie['curly{brackets}']).toBe('ok')
-  })
-
-  it('Should parse one cookie specified by a name that is not an RFC 6265 token', () => {
-    const cookieString = 'paraglide:lang=en; test=ok'
-    const cookie: Cookie = parse(cookieString, 'paraglide:lang')
-    expect(cookie['paraglide:lang']).toBe('en')
-    expect(cookie['test']).toBeUndefined()
-  })
-
-  it('Should ignore cookie names containing non-ASCII or control characters', () => {
-    const cookieString = 'yummy_cookie=choco; クッキー=strawberry; bad\x01name=sugar'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['クッキー']).toBeUndefined()
-    expect(cookie['bad\x01name']).toBeUndefined()
-  })
-
-  it('Should ignore invalid cookie values', () => {
-    const cookieString = 'yummy_cookie=choco\\nchip; tasty_cookie=strawberry; best_cookie="sugar'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['yummy_cookie']).toBeUndefined()
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-    expect(cookie['best_cookie\\']).toBeUndefined()
-  })
-
-  it('Should ignore NBSP-prefixed cookie names when parsing one cookie by name', () => {
-    const cookieString = '\u00a0dummy-cookie=evil; dummy-cookie=victim'
-    const cookie: Cookie = parse(cookieString, 'dummy-cookie')
-    expect(cookie['dummy-cookie']).toBe('victim')
-  })
-
-  it('Should not collapse NBSP-prefixed cookie names when parsing all cookies', () => {
-    const cookieString = 'dummy-cookie=victim; \u00a0dummy-cookie=evil'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['dummy-cookie']).toBe('victim')
-    expect(cookie['\u00a0dummy-cookie']).toBeUndefined()
-  })
-
-  it('Should return the first value for duplicate cookie names', () => {
-    const cookieString = 'a=first; a=last'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['a']).toBe('first')
-  })
-
-  it('Should return the first value for duplicate cookie names when parsed by name', () => {
-    const cookieString = 'a=first; a=last'
-    const cookie: Cookie = parse(cookieString, 'a')
-    expect(cookie['a']).toBe('first')
-  })
-
-  it('Should return consistent values between parse() and parse(name) for duplicates', () => {
-    const cookieString = 'session=legit; other=x; session=evil'
-    expect(parse(cookieString)['session']).toBe(parse(cookieString, 'session')['session'])
-  })
-
-  it('Should parse cookies whose names collide with Object.prototype properties', () => {
-    const cookieString = 'toString=foo; hasOwnProperty=bar; constructor=baz'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['toString']).toBe('foo')
-    expect(cookie['hasOwnProperty']).toBe('bar')
-    expect(cookie['constructor']).toBe('baz')
-  })
-
-  it('Should parse a cookie whose name collides with Object.prototype when parsed by name', () => {
-    const cookieString = 'toString=foo'
-    const cookie: Cookie = parse(cookieString, 'toString')
-    expect(cookie['toString']).toBe('foo')
-  })
-
-  it('Should keep first-wins behavior for cookies whose names collide with Object.prototype', () => {
-    const cookieString = 'toString=first; toString=last'
-    const cookie: Cookie = parse(cookieString)
-    expect(cookie['toString']).toBe('first')
-  })
-
-  it('Should parse signed cookies', async () => {
-    const secret = 'secret ingredient'
-    const cookieString =
-      'yummy_cookie=choco.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D; tasty_cookie = strawberry.I9qAeGQOvWjCEJgRPmrw90JjYpnnX2C9zoOiGSxh1Ig%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-  })
-
-  it('Should parse signed cookies with binary secret', async () => {
-    const secret = new Uint8Array([
-      172, 142, 204, 63, 210, 136, 58, 143, 25, 18, 159, 16, 161, 34, 94,
-    ])
-    const cookieString =
-      'yummy_cookie=choco.8Km4IwZETZdwiOfrT7KgYjKXwiO98XIkms0tOtRa2TA%3D; tasty_cookie = strawberry.TbV33P%2Bi1K0JTxMzNYq7FV9fB4s2VlQcBCBFDxTrUSg%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-  })
-
-  it('Should parse signed cookies containing the signature separator', async () => {
-    const secret = 'secret ingredient'
-    const cookieString = 'yummy_cookie=choco.chip.2%2FJA0c68Y3zm0DvSvHyR6IRysDWmHW0LfoaC0AkyOpw%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['yummy_cookie']).toBe('choco.chip')
-  })
-
-  it('Should parse signed cookies and return "false" for wrong signature', async () => {
-    const secret = 'secret ingredient'
-    // tasty_cookie has invalid signature
-    const cookieString =
-      'yummy_cookie=choco.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D; tasty_cookie = strawberry.LAa7RX43t2vCrLNcKmNG65H41OkyV02sraRPuY5RuVg%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['yummy_cookie']).toBe('choco')
-    expect(cookie['tasty_cookie']).toBe(false)
-  })
-
-  it('Should parse signed cookie with empty string value', async () => {
-    const secret = 'secret ingredient'
-    const cookieString = await serializeSigned('empty_cookie', '', secret)
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['empty_cookie']).toBe('')
-  })
-
-  it('Should parse signed cookies and return "false" for corrupt signature', async () => {
-    const secret = 'secret ingredient'
-    // yummy_cookie has corrupt signature (i.e. invalid base64 encoding)
-    // best_cookie has a shape that matches the signature format but isn't actually a signature
-    const cookieString =
-      'yummy_cookie=choco.?dFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D; tasty_cookie = strawberry.I9qAeGQOvWjCEJgRPmrw90JjYpnnX2C9zoOiGSxh1Ig%3D; best_cookie=sugar.valueShapedLikeASignatureButIsNotASignature%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['yummy_cookie']).toBe(false)
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-    expect(cookie['best_cookie']).toBe(false)
-  })
-
-  it('Should parse one signed cookie specified by name', async () => {
-    const secret = 'secret ingredient'
-    const cookieString =
-      'yummy_cookie=choco.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D; tasty_cookie = strawberry.I9qAeGQOvWjCEJgRPmrw90JjYpnnX2C9zoOiGSxh1Ig%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret, 'tasty_cookie')
-    expect(cookie['yummy_cookie']).toBeUndefined()
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-  })
-
-  it('Should parse one signed cookie specified by name and return "false" for wrong signature', async () => {
-    const secret = 'secret ingredient'
-    // tasty_cookie has invalid signature
-    const cookieString =
-      'yummy_cookie=choco.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D; tasty_cookie = strawberry.LAa7RX43t2vCrLNcKmNG65H41OkyV02sraRPuY5RuVg%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret, 'tasty_cookie')
-    expect(cookie['yummy_cookie']).toBeUndefined()
-    expect(cookie['tasty_cookie']).toBe(false)
-  })
-
-  it('Should parse signed cookies and ignore regular cookies', async () => {
-    const secret = 'secret ingredient'
-    // also contains another cookie with a '.' in its value to test it is not misinterpreted as signed cookie
-    const cookieString =
-      'yummy_cookie=choco; tasty_cookie = strawberry.I9qAeGQOvWjCEJgRPmrw90JjYpnnX2C9zoOiGSxh1Ig%3D; great_cookie=rating3.5'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['yummy_cookie']).toBeUndefined()
-    expect(cookie['tasty_cookie']).toBe('strawberry')
-    expect(cookie['great_cookie']).toBeUndefined()
-  })
-
-  it('Should ignore NBSP-prefixed signed cookie names when parsing one cookie by name', async () => {
-    const secret = 'secret ingredient'
-    const cookieString =
-      '\u00a0dummy-cookie=evil.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D; dummy-cookie=choco.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret, 'dummy-cookie')
-    expect(cookie['dummy-cookie']).toBe('choco')
-  })
-
-  it('Should return the first signed cookie when there are duplicate names', async () => {
-    const secret = 'secret ingredient'
-    const cookieString =
-      'yummy_cookie=choco.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D; yummy_cookie=strawberry.I9qAeGQOvWjCEJgRPmrw90JjYpnnX2C9zoOiGSxh1Ig%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['yummy_cookie']).toBe('choco')
-  })
-
-  it('Should parse signed cookies whose names collide with Object.prototype properties', async () => {
-    const secret = 'secret ingredient'
-    const cookieString = 'toString=choco.UdFR2rBpS1GsHfGlUiYyMIdqxqwuEgplyQIgTJgpGWY%3D'
-    const cookie: SignedCookie = await parseSigned(cookieString, secret)
-    expect(cookie['toString']).toBe('choco')
-  })
-})
-
-describe('Set cookie', () => {
-  it('Should serialize cookie', () => {
-    const serialized = serialize('delicious_cookie', 'macha')
-    expect(serialized).toBe('delicious_cookie=macha')
-  })
-
-  it('Should serialize cookie with all options', () => {
-    const serialized = serialize('__Secure-great_cookie', 'banana', {
-      path: '/',
-      secure: true,
-      domain: 'example.com',
-      httpOnly: true,
-      maxAge: 1000,
-      expires: new Date(Date.UTC(2000, 11, 24, 10, 30, 59, 900)),
-      sameSite: 'Strict',
-      priority: 'High',
-      partitioned: true,
-    })
-    expect(serialized).toBe(
-      '__Secure-great_cookie=banana; Max-Age=1000; Domain=example.com; Path=/; Expires=Sun, 24 Dec 2000 10:30:59 GMT; HttpOnly; Secure; SameSite=Strict; Priority=High; Partitioned'
-    )
-  })
-
-  it('Should serialize __Host- cookie with all valid options', () => {
-    const serialized = serialize('__Host-great_cookie', 'banana', {
-      path: '/',
-      secure: true,
-      httpOnly: true,
-      maxAge: 1000,
-      expires: new Date(Date.UTC(2000, 11, 24, 10, 30, 59, 900)),
-      sameSite: 'Strict',
-      priority: 'High',
-      partitioned: true,
-    })
-    expect(serialized).toBe(
-      '__Host-great_cookie=banana; Max-Age=1000; Path=/; Expires=Sun, 24 Dec 2000 10:30:59 GMT; HttpOnly; Secure; SameSite=Strict; Priority=High; Partitioned'
-    )
-  })
-
-  it('Should serialize a signed cookie', async () => {
-    const secret = 'secret chocolate chips'
-    const serialized = await serializeSigned('delicious_cookie', 'macha', secret)
-    expect(serialized).toBe(
-      'delicious_cookie=macha.diubJPY8O7hI1pLa42QSfkPiyDWQ0I4DnlACH%2FN2HaA%3D'
-    )
-  })
-
-  it('Should serialize signed cookie with all options', async () => {
-    const secret = 'secret chocolate chips'
-    const serialized = await serializeSigned('great_cookie', 'banana', secret, {
-      path: '/',
-      secure: true,
-      domain: 'example.com',
-      httpOnly: true,
-      maxAge: 1000,
-      expires: new Date(Date.UTC(2000, 11, 24, 10, 30, 59, 900)),
-      sameSite: 'Strict',
-      priority: 'High',
-      partitioned: true,
-    })
-    expect(serialized).toBe(
-      'great_cookie=banana.hSo6gB7YT2db0WBiEAakEmh7dtwEL0DSp76G23WvHuQ%3D; Max-Age=1000; Domain=example.com; Path=/; Expires=Sun, 24 Dec 2000 10:30:59 GMT; HttpOnly; Secure; SameSite=Strict; Priority=High; Partitioned'
-    )
-  })
-
-  it('Should serialize cookie with maxAge is 0', () => {
-    const serialized = serialize('great_cookie', 'banana', {
-      maxAge: 0,
-    })
-    expect(serialized).toBe('great_cookie=banana; Max-Age=0')
-  })
-
-  it('Should serialize cookie with maxAge is -1', () => {
-    const serialized = serialize('great_cookie', 'banana', {
-      maxAge: -1,
-    })
-    expect(serialized).toBe('great_cookie=banana')
-  })
-
-  it('Should throw Error cookie with maxAge grater than 400days', () => {
-    expect(() => {
-      serialize('great_cookie', 'banana', {
-        maxAge: 3600 * 24 * 401,
-      })
-    }).toThrowError(
-      'Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.'
-    )
-  })
-
-  it('Should throw Error cookie with expires grater than 400days', () => {
-    const now = Date.now()
-    const day401 = new Date(now + 1000 * 3600 * 24 * 401)
-    expect(() => {
-      serialize('great_cookie', 'banana', {
-        expires: day401,
-      })
-    }).toThrowError(
-      'Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.'
-    )
-  })
-
-  it('Should throw Error Partitioned cookie without Secure attributes', () => {
-    expect(() => {
-      serialize('great_cookie', 'banana', {
-        partitioned: true,
-      })
-    }).toThrowError('Partitioned Cookie must have Secure attributes')
-  })
-
-  it('Should throw Error cookie with domain, path, sameSite, or priority containing ";", "\\r", or "\\n"', () => {
-    // domain
-    expect(() => {
-      serialize('great_cookie', 'banana', { domain: 'example.com;evil' })
-    }).toThrowError('domain must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { domain: 'example.com\revil' })
-    }).toThrowError('domain must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { domain: 'example.com\nevil' })
-    }).toThrowError('domain must not contain ";", "\\r", or "\\n"')
-
-    // path
-    expect(() => {
-      serialize('great_cookie', 'banana', { path: '/;evil' })
-    }).toThrowError('path must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { path: '/\revil' })
-    }).toThrowError('path must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { path: '/\nevil' })
-    }).toThrowError('path must not contain ";", "\\r", or "\\n"')
-
-    // sameSite
-    expect(() => {
-      serialize('great_cookie', 'banana', { sameSite: 'Strict;evil' as 'Strict' })
-    }).toThrowError('sameSite must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { sameSite: 'Strict\revil' as 'Strict' })
-    }).toThrowError('sameSite must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { sameSite: 'Strict\nevil' as 'Strict' })
-    }).toThrowError('sameSite must not contain ";", "\\r", or "\\n"')
-
-    // priority
-    expect(() => {
-      serialize('great_cookie', 'banana', { priority: 'High;evil' as 'High' })
-    }).toThrowError('priority must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { priority: 'High\revil' as 'High' })
-    }).toThrowError('priority must not contain ";", "\\r", or "\\n"')
-    expect(() => {
-      serialize('great_cookie', 'banana', { priority: 'High\nevil' as 'High' })
-    }).toThrowError('priority must not contain ";", "\\r", or "\\n"')
-  })
-
-  it('Should throw Error for invalid cookie name', () => {
-    expect(() => {
-      serialize('legit\r\nX-Injected: evil', 'value')
-    }).toThrowError('Invalid cookie name')
-    expect(() => {
-      serialize('bad;name', 'value')
-    }).toThrowError('Invalid cookie name')
-    expect(() => {
-      serialize('bad=name', 'value')
-    }).toThrowError('Invalid cookie name')
-  })
-
-  it('Should serialize cookie with lowercase priority values', () => {
-    const lowSerialized = serialize('test_cookie', 'value', {
-      priority: 'low',
-    })
-    expect(lowSerialized).toBe('test_cookie=value; Priority=Low')
-
-    const mediumSerialized = serialize('test_cookie', 'value', {
-      priority: 'medium',
-    })
-    expect(mediumSerialized).toBe('test_cookie=value; Priority=Medium')
-
-    const highSerialized = serialize('test_cookie', 'value', {
-      priority: 'high',
-    })
-    expect(highSerialized).toBe('test_cookie=value; Priority=High')
-  })
-})

package/plugins/acryl-router/src/core/utils/crypto.test.ts

@@ -1,43 +0,0 @@
-import { createHash } from 'node:crypto'
-import { md5, sha1, sha256 } from './crypto.ts'
-
-describe('crypto', () => {
-  it('sha256', async () => {
-    expect(await sha256('acryl')).toBe(
-      '1722bce316636434b7346179cda6e5918d1265e875548d8393d897d0e8056490'
-    )
-    expect(await sha256('炎')).toBe(
-      '1fddc5a562ee1fbeb4fc6def7d4be4911fcdae4273b02ae3a507b170ba0ea169'
-    )
-    expect(await sha256('abcdedf')).not.toBe('abcdef')
-  })
-
-  it('sha1', async () => {
-    expect(await sha1('acryl')).toBe('a0d04d622e8eee4b96ec3e768158f79849e4feaa')
-    expect(await sha1('炎')).toBe('d56e09ae2421b2b8a0b5ee5fdceaed663c8c9472')
-    expect(await sha1('abcdedf')).not.toBe('abcdef')
-  })
-
-  // MD5 is not part of the WebCrypto standard.
-  // Node.js' Web Crypto API does not support it (But Cloudflare Workers supports it).
-  // We should skip this test in a Node.js environment.
-  it.skip('md5', async () => {
-    expect(await md5('acryl')).toBe('6d6de29f8c2b6b8741b0d549b556de5c')
-    expect(await md5('炎')).toBe('f620d89a5a782c22b4420acb39121be3')
-    expect(await md5('abcdedf')).not.toBe('abcdef')
-  })
-
-  it('Should not be the same values - compare difference objects', async () => {
-    expect(await sha256({ foo: 'bar' })).not.toEqual(
-      await sha256({
-        bar: 'foo',
-      })
-    )
-  })
-
-  it('Should create hash for Buffer', async () => {
-    const hash = createHash('sha256').update(new Uint8Array(1)).digest('hex')
-    expect(await sha256(new Uint8Array(1))).toBe(hash)
-    expect(await sha256(new Uint8Array(1))).not.toEqual(await sha256(new Uint8Array(2)))
-  })
-})

package/plugins/acryl-router/src/core/utils/encode.test.ts

@@ -1,61 +0,0 @@
-import { decodeBase64Url, encodeBase64Url } from './encode.ts'
-
-const toURLBase64 = (base64String: string): string =>
-  base64String.replace(/\+|\//g, (m) => ({ '+': '-', '/': '_' })[m] ?? m)
-
-const str2UInt8Array = (s: string): Uint8Array<ArrayBuffer> => {
-  const buffer = new Uint8Array<ArrayBuffer>(new ArrayBuffer(s.length))
-  for (let i = 0, len = buffer.byteLength; i < len; i++) {
-    buffer[i] = s.charCodeAt(i)
-  }
-  return buffer
-}
-
-describe('base64', () => {
-  const utf8Encoder = new TextEncoder()
-  describe.each([
-    // basic
-    [utf8Encoder.encode('Hello, 世界'), 'SGVsbG8sIOS4lueVjA=='],
-    [utf8Encoder.encode('炎'), '54KO'],
-    [utf8Encoder.encode('🔥'), '8J+UpQ=='],
-    [
-      utf8Encoder.encode('http://github.com/acryldev/acryl'),
-      'aHR0cDovL2dpdGh1Yi5jb20vYWNyeWxkZXYvYWNyeWw=',
-    ],
-
-    // RFC 3548 examples
-    [str2UInt8Array('\x14\xfb\x9c\x03\xd9\x7e'), 'FPucA9l+'],
-    [str2UInt8Array('\x14\xfb\x9c\x03\xd9'), 'FPucA9k='],
-    [str2UInt8Array('\x14\xfb\x9c\x03'), 'FPucAw=='],
-
-    // RFC 4648 examples
-    [str2UInt8Array(''), ''],
-    [str2UInt8Array('f'), 'Zg=='],
-    [str2UInt8Array('fo'), 'Zm8='],
-    [str2UInt8Array('foo'), 'Zm9v'],
-    [str2UInt8Array('foob'), 'Zm9vYg=='],
-    [str2UInt8Array('fooba'), 'Zm9vYmE='],
-    [str2UInt8Array('foobar'), 'Zm9vYmFy'],
-
-    // Wikipedia examples
-    [str2UInt8Array('sure.'), 'c3VyZS4='],
-    [str2UInt8Array('sure'), 'c3VyZQ=='],
-    [str2UInt8Array('sur'), 'c3Vy'],
-    [str2UInt8Array('su'), 'c3U='],
-    [str2UInt8Array('leasure.'), 'bGVhc3VyZS4='],
-    [str2UInt8Array('easure.'), 'ZWFzdXJlLg=='],
-    [str2UInt8Array('asure.'), 'YXN1cmUu'],
-    [str2UInt8Array('sure.'), 'c3VyZS4='],
-  ])('%s, %s', (stdDecoded, stdEncoded) => {
-    it('encode', () => {
-      const got = encodeBase64Url(stdDecoded.buffer)
-      const want = toURLBase64(stdEncoded)
-      expect(got).toStrictEqual(want)
-    })
-    it('decode', () => {
-      const got = decodeBase64Url(toURLBase64(stdEncoded))
-      const want = stdDecoded
-      expect(got).toStrictEqual(want)
-    })
-  })
-})