acrylblends 0.6.3 → 0.7.0

package/plugins/acryl-router/src/core/middleware/language/index.test.ts

@@ -1,552 +0,0 @@
-import { languageDetector } from './index.ts'
-import { Acryl } from '../../app.ts'
-import { DEFAULT_OPTIONS, detectors, normalizeLanguage } from './language.ts'
-
-describe('languageDetector', () => {
-  const createTestApp = (options = {}) => {
-    const app = new Acryl()
-
-    app.use('/*', languageDetector(options))
-
-    app.get('/*', (c) => c.text(c.get('language')))
-
-    return app
-  }
-
-  describe('Query Parameter Detection', () => {
-    it('should detect language from query parameter', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr', 'es'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/?lang=fr')
-      expect(await res.text()).toBe('fr')
-    })
-
-    it('should ignore unsupported languages in query', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/?lang=de')
-      expect(await res.text()).toBe('en')
-    })
-  })
-
-  describe('Cookie Detection', () => {
-    it('should detect language from cookie', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          cookie: 'language=fr',
-        },
-      })
-      expect(await res.text()).toBe('fr')
-    })
-
-    it('should cache detected language in cookie when enabled', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        caches: ['cookie'],
-      })
-
-      const res = await app.request('/?lang=fr')
-      expect(res.headers.get('set-cookie')).toContain('language=fr')
-    })
-  })
-
-  describe('Header Detection', () => {
-    it('should detect language from Accept-Language header', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr', 'es'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'fr-FR,fr;q=0.9,en;q=0.8',
-        },
-      })
-      expect(await res.text()).toBe('fr')
-    })
-
-    it('should fallback to language code when locale code is not in supportedLanguages', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'ja'],
-        fallbackLanguage: 'en',
-        order: ['header'],
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'ja-JP',
-        },
-      })
-      expect(await res.text()).toBe('ja')
-    })
-
-    it('should not detect a language explicitly rejected with q=0', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['fr', 'en'],
-        fallbackLanguage: 'en',
-        order: ['header'],
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'fr;q=0',
-        },
-      })
-      expect(await res.text()).toBe('en')
-    })
-
-    it('should skip q=0 languages before falling back to the default', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['fr', 'en'],
-        fallbackLanguage: 'en',
-        order: ['header'],
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'fr;q=0,de;q=0.8',
-        },
-      })
-      expect(await res.text()).toBe('en')
-    })
-
-    it('should continue to the next detector after a zero-quality language', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['fr', 'en', 'ja'],
-        fallbackLanguage: 'en',
-        order: ['header', 'querystring'],
-      })
-
-      const res = await app.request('/?lang=ja', {
-        headers: { 'accept-language': 'fr;q=0' },
-      })
-      expect(await res.text()).toBe('ja')
-      expect(res.headers.get('set-cookie')).toContain('language=ja')
-    })
-
-    it('should match after multiple truncations', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['zh-Hant', 'en'],
-        fallbackLanguage: 'en',
-        order: ['header'],
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'zh-Hant-CN',
-        },
-      })
-      expect(await res.text()).toBe('zh-Hant')
-    })
-
-    it('should select the longest truncated match regardless of supported language order', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['zh', 'zh-Hant'],
-        fallbackLanguage: 'zh',
-        order: ['header'],
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'zh-Hant-CN',
-        },
-      })
-      expect(await res.text()).toBe('zh-Hant')
-    })
-
-    it('should fallback when truncation does not match any supported language', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'ja'],
-        fallbackLanguage: 'en',
-        order: ['header'],
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'ko-KR',
-        },
-      })
-      expect(await res.text()).toBe('en')
-    })
-
-    it('should prefer exact match over truncated match', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['fr', 'fr-CA'],
-        fallbackLanguage: 'fr',
-        order: ['header'],
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'fr-CA',
-        },
-      })
-      expect(await res.text()).toBe('fr-CA')
-    })
-
-    it('should handle case-insensitive truncation matching', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'ja'],
-        fallbackLanguage: 'en',
-        order: ['header'],
-        ignoreCase: true,
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'JA-JP',
-        },
-      })
-      expect(await res.text()).toBe('ja')
-    })
-
-    it('should handle malformed Accept-Language headers', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'invalid;header;;format',
-        },
-      })
-      expect(await res.text()).toBe('en')
-    })
-
-    it('should handle invalid header lookup key gracefully', async () => {
-      const app = createTestApp({
-        order: ['header'],
-        lookupFromHeaderKey: 'accept\nlanguage',
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/', {
-        headers: {
-          'accept-language': 'fr',
-        },
-      })
-
-      expect(await res.text()).toBe('en')
-    })
-  })
-
-  describe('Language Normalization', () => {
-    it('should preserve the configured value for a case-insensitive truncated match', () => {
-      expect(
-        normalizeLanguage('zh-HANT-CN', {
-          ...DEFAULT_OPTIONS,
-          supportedLanguages: ['en', 'ZH-Hant'],
-        })
-      ).toBe('ZH-Hant')
-    })
-
-    it('should handle a large unsupported language tag', () => {
-      const unsupportedLanguage = 'x-'.repeat(30_000).slice(0, -1)
-
-      expect(
-        normalizeLanguage(unsupportedLanguage, {
-          ...DEFAULT_OPTIONS,
-          supportedLanguages: ['en', 'ja'],
-        })
-      ).toBeUndefined()
-    })
-  })
-
-  describe('Path Detection', () => {
-    it('should detect language from path', async () => {
-      const app = createTestApp({
-        order: ['path'],
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        lookupFromPathIndex: 0,
-      })
-
-      const res = await app.request('/fr/page')
-      expect(await res.text()).toBe('fr')
-    })
-
-    it('should handle invalid path index gracefully', async () => {
-      const app = createTestApp({
-        order: ['path'],
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        lookupFromPathIndex: 99,
-      })
-
-      const res = await app.request('/fr/page')
-      expect(await res.text()).toBe('en')
-    })
-
-    it('should detect language from original URL when getPath modifies the path', async () => {
-      const app = new Acryl({
-        getPath: (req) => {
-          const url = new URL(req.url)
-          let pathname = url.pathname
-          // Remove language prefix /fr/
-          if (pathname.startsWith('/fr/')) {
-            pathname = pathname.replace('/fr/', '/')
-          }
-          return pathname
-        },
-      })
-
-      app.use(
-        '*',
-        languageDetector({
-          order: ['path'],
-          supportedLanguages: ['en', 'fr'],
-          fallbackLanguage: 'en',
-          lookupFromPathIndex: 0,
-        })
-      )
-
-      app.get('/home', (c) => c.text(c.get('language')))
-
-      const res = await app.request('/fr/home')
-      expect(await res.text()).toBe('fr')
-    })
-  })
-
-  describe('Detection Order', () => {
-    it('should respect detection order', async () => {
-      const app = createTestApp({
-        order: ['cookie', 'querystring'],
-        supportedLanguages: ['en', 'fr', 'es'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/?lang=fr', {
-        headers: {
-          cookie: 'language=es',
-        },
-      })
-
-      // Since cookie is first in order, it should use 'es'
-      expect(await res.text()).toBe('es')
-    })
-
-    it('should fall back to next detector if first fails', async () => {
-      const app = createTestApp({
-        order: ['cookie', 'querystring'],
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-      })
-
-      const res = await app.request('/?lang=fr') // No cookie
-      expect(await res.text()).toBe('fr') // Should use querystring
-    })
-  })
-
-  describe('Language Conversion', () => {
-    it('should apply language conversion function', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        convertDetectedLanguage: (lang: string) => lang.split('-')[0],
-      })
-
-      const res = await app.request('/?lang=fr-FR')
-      expect(await res.text()).toBe('fr')
-    })
-
-    it('should handle case sensitivity according to options', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        ignoreCase: false,
-      })
-
-      const res = await app.request('/?lang=FR')
-      expect(await res.text()).toBe('en') // Falls back because case doesn't match
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should fall back to default language on error', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-      })
-
-      const detector = vi.spyOn(detectors, 'querystring').mockImplementation(() => {
-        throw new Error('Simulated error')
-      })
-
-      const res = await app.request('/?lang=fr')
-      expect(await res.text()).toBe('en')
-
-      detector.mockRestore()
-    })
-
-    it('should handle missing cookie values gracefully', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        order: ['cookie'],
-      })
-
-      const res = await app.request('/')
-      expect(await res.text()).toBe('en')
-    })
-
-    it('should handle errors in convertDetectedLanguage function', async () => {
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        convertDetectedLanguage: (lang: string) => {
-          if (lang === 'fr') {
-            throw new Error('Simulated error in convertDetectedLanguage')
-          }
-          return lang
-        },
-      })
-
-      const res = await app.request('/?lang=fr')
-      expect(await res.text()).toBe('en')
-    })
-  })
-
-  describe('Configuration Validation', () => {
-    it('should throw if fallback language is not in supported languages', () => {
-      expect(() => {
-        createTestApp({
-          supportedLanguages: ['fr', 'es'],
-          fallbackLanguage: 'en',
-        })
-      }).toThrow()
-    })
-
-    it('should throw if path index is negative', () => {
-      expect(() => {
-        createTestApp({
-          lookupFromPathIndex: -1,
-        })
-      }).toThrow()
-    })
-
-    it('should handle empty supported languages list', () => {
-      expect(() => {
-        createTestApp({
-          supportedLanguages: [],
-        })
-      }).toThrow()
-    })
-
-    it('should handle invalid order option', async () => {
-      expect(() => {
-        createTestApp({
-          order: ['invalidDetector' as any],
-        })
-      }).toThrow()
-    })
-
-    it('should handle early return for caches', async () => {
-      const app = createTestApp({
-        caches: ['test'],
-        supportedLanguages: ['en'],
-      })
-
-      const res = await app.request('/?lang=en')
-
-      expect(await res.text()).toBe('en')
-      expect(res.headers.get('set-cookie')).toBeNull()
-    })
-  })
-
-  describe('Debug Mode', () => {
-    it('should log errors in debug mode', async () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error')
-
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        debug: true,
-      })
-
-      const detector = vi.spyOn(detectors, 'querystring').mockImplementation(() => {
-        throw new Error('Simulated error')
-      })
-
-      await app.request('/?lang=fr')
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        'Error in querystring detector:',
-        expect.any(Error)
-      )
-
-      detector.mockRestore()
-      consoleErrorSpy.mockRestore()
-    })
-
-    // The log test remains unchanged
-    it('should log debug information when enabled', async () => {
-      const consoleSpy = vi.spyOn(console, 'log')
-
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        debug: true,
-      })
-
-      await app.request('/?lang=fr')
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Language detected from querystring')
-      )
-
-      consoleSpy.mockRestore()
-    })
-
-    it('should handle cookie cache errors in debug mode', async () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error')
-
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        caches: ['cookie'],
-        lookupCookie: 'bad cookie',
-        debug: true,
-      })
-
-      const res = await app.request('/?lang=fr')
-
-      expect(await res.text()).toBe('fr')
-      expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to cache language:', expect.any(Error))
-
-      consoleErrorSpy.mockRestore()
-    })
-
-    it('should silently handle cookie cache errors when debug mode is disabled', async () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-      const app = createTestApp({
-        supportedLanguages: ['en', 'fr'],
-        fallbackLanguage: 'en',
-        caches: ['cookie'],
-        lookupCookie: 'bad cookie',
-        debug: false,
-      })
-
-      const res = await app.request('/?lang=fr')
-
-      expect(await res.text()).toBe('fr')
-      expect(consoleErrorSpy).not.toHaveBeenCalled()
-
-      consoleErrorSpy.mockRestore()
-    })
-  })
-})