@gravito/cosmos 3.1.0 → 3.2.1

package/tests/unit/memory-loader.test.ts

@@ -0,0 +1,130 @@
+/**
+ * @file packages/cosmos/tests/unit/memory-loader.test.ts
+ * @description MemoryLoader 單元測試
+ */
+
+import { describe, expect, it } from 'bun:test'
+import { MemoryLoader } from '../../src/loaders/MemoryLoader'
+
+describe('MemoryLoader', () => {
+  it('should load translations from memory', async () => {
+    const loader = new MemoryLoader({
+      translations: {
+        en: { hello: 'Hello', welcome: 'Welcome' },
+        'zh-TW': { hello: '你好', welcome: '歡迎' },
+      },
+    })
+
+    const en = await loader.load('en')
+    expect(en).toEqual({ hello: 'Hello', welcome: 'Welcome' })
+
+    const zhTW = await loader.load('zh-TW')
+    expect(zhTW).toEqual({ hello: '你好', welcome: '歡迎' })
+  })
+
+  it('should return null for missing locale', async () => {
+    const loader = new MemoryLoader({
+      translations: { en: { hello: 'Hello' } },
+    })
+
+    const result = await loader.load('fr')
+    expect(result).toBeNull()
+  })
+
+  it('should support fallback chain', async () => {
+    const primary = new MemoryLoader({
+      translations: { en: { hello: 'Hello' } },
+    })
+
+    const fallback = new MemoryLoader({
+      translations: { fr: { hello: 'Bonjour' } },
+    })
+
+    primary.fallback(fallback)
+
+    const result = await primary.load('fr')
+    expect(result).toEqual({ hello: 'Bonjour' })
+  })
+
+  it('should allow adding translations dynamically', async () => {
+    const loader = new MemoryLoader({
+      translations: { en: { hello: 'Hello' } },
+    })
+
+    loader.addTranslations('fr', { hello: 'Bonjour' })
+
+    const result = await loader.load('fr')
+    expect(result).toEqual({ hello: 'Bonjour' })
+  })
+
+  it('should merge when adding translations to existing locale', async () => {
+    const loader = new MemoryLoader({
+      translations: { en: { hello: 'Hello' } },
+    })
+
+    loader.addTranslations('en', { goodbye: 'Goodbye' })
+
+    const result = await loader.load('en')
+    expect(result).toEqual({ hello: 'Hello', goodbye: 'Goodbye' })
+  })
+
+  it('should allow removing translations', async () => {
+    const loader = new MemoryLoader({
+      translations: {
+        en: { hello: 'Hello' },
+        fr: { hello: 'Bonjour' },
+      },
+    })
+
+    loader.removeTranslations('fr')
+
+    const result = await loader.load('fr')
+    expect(result).toBeNull()
+  })
+
+  it('should return loaded locales', () => {
+    const loader = new MemoryLoader({
+      translations: {
+        en: { hello: 'Hello' },
+        'zh-TW': { hello: '你好' },
+        fr: { hello: 'Bonjour' },
+      },
+    })
+
+    const locales = loader.getLoadedLocales()
+    expect(locales).toContain('en')
+    expect(locales).toContain('zh-TW')
+    expect(locales).toContain('fr')
+    expect(locales.length).toBe(3)
+  })
+
+  it('should check if locale exists', () => {
+    const loader = new MemoryLoader({
+      translations: { en: { hello: 'Hello' } },
+    })
+
+    expect(loader.hasLocale('en')).toBe(true)
+    expect(loader.hasLocale('fr')).toBe(false)
+  })
+
+  it('should handle nested translations', async () => {
+    const loader = new MemoryLoader({
+      translations: {
+        en: {
+          auth: {
+            login: 'Login',
+            logout: 'Logout',
+          },
+        },
+      },
+    })
+
+    const result = await loader.load('en')
+    expect(result).toEqual({
+      auth: {
+        login: 'Login',
+        logout: 'Logout',
+      },
+    })
+  })
+})

package/tests/unit/path-utils.test.ts

@@ -0,0 +1,135 @@
+/**
+ * @file packages/cosmos/tests/unit/path-utils.test.ts
+ * @description Path utils 單元測試
+ */
+
+import { describe, expect, it } from 'bun:test'
+import { pathUtils } from '../../src/runtime/path-utils'
+
+describe('Path Utils', () => {
+  describe('join', () => {
+    it('should join path segments', () => {
+      expect(pathUtils.join('foo', 'bar', 'baz.txt')).toBe('foo/bar/baz.txt')
+    })
+
+    it('should handle leading slashes', () => {
+      expect(pathUtils.join('/foo', 'bar')).toBe('/foo/bar')
+    })
+
+    it('should handle trailing slashes', () => {
+      expect(pathUtils.join('foo/', 'bar/')).toBe('foo/bar')
+    })
+
+    it('should filter empty segments', () => {
+      expect(pathUtils.join('', 'foo', '', 'bar')).toBe('foo/bar')
+    })
+
+    it('should handle multiple slashes', () => {
+      expect(pathUtils.join('foo//bar///baz')).toBe('foo/bar/baz')
+    })
+  })
+
+  describe('basename', () => {
+    it('should return base name', () => {
+      expect(pathUtils.basename('/foo/bar/baz.txt')).toBe('baz.txt')
+    })
+
+    it('should remove extension if provided', () => {
+      expect(pathUtils.basename('/foo/bar/baz.txt', '.txt')).toBe('baz')
+    })
+
+    it('should handle trailing slash', () => {
+      expect(pathUtils.basename('/foo/bar/')).toBe('bar')
+    })
+
+    it('should handle root path', () => {
+      expect(pathUtils.basename('/')).toBe('')
+    })
+  })
+
+  describe('dirname', () => {
+    it('should return directory name', () => {
+      expect(pathUtils.dirname('/foo/bar/baz.txt')).toBe('/foo/bar')
+    })
+
+    it('should handle root path', () => {
+      expect(pathUtils.dirname('/foo')).toBe('/')
+    })
+
+    it('should handle relative path', () => {
+      expect(pathUtils.dirname('foo/bar')).toBe('foo')
+    })
+
+    it('should handle single segment', () => {
+      expect(pathUtils.dirname('foo')).toBe('.')
+    })
+  })
+
+  describe('extname', () => {
+    it('should return file extension', () => {
+      expect(pathUtils.extname('index.html')).toBe('.html')
+    })
+
+    it('should handle multiple dots', () => {
+      expect(pathUtils.extname('index.coffee.md')).toBe('.md')
+    })
+
+    it('should handle dot at end', () => {
+      expect(pathUtils.extname('index.')).toBe('.')
+    })
+
+    it('should return empty for no extension', () => {
+      expect(pathUtils.extname('index')).toBe('')
+    })
+
+    it('should handle hidden files', () => {
+      // .gitignore 整個被視為副檔名
+      expect(pathUtils.extname('.gitignore')).toBe('.gitignore')
+    })
+  })
+
+  describe('isAbsolute', () => {
+    it('should detect Unix absolute path', () => {
+      expect(pathUtils.isAbsolute('/foo/bar')).toBe(true)
+    })
+
+    it('should detect relative path', () => {
+      expect(pathUtils.isAbsolute('foo/bar')).toBe(false)
+    })
+
+    it('should detect Windows absolute path', () => {
+      expect(pathUtils.isAbsolute('C:/foo/bar')).toBe(true)
+      expect(pathUtils.isAbsolute('D:\\foo\\bar')).toBe(true)
+    })
+  })
+
+  describe('normalize', () => {
+    it('should normalize path with dots', () => {
+      expect(pathUtils.normalize('/foo/bar//baz/./qux/../quux')).toBe('/foo/bar/baz/quux')
+    })
+
+    it('should handle relative path with ..', () => {
+      expect(pathUtils.normalize('foo/../bar')).toBe('bar')
+    })
+
+    it('should preserve leading .. in relative paths', () => {
+      expect(pathUtils.normalize('../foo/bar')).toBe('../foo/bar')
+    })
+
+    it('should remove . segments', () => {
+      expect(pathUtils.normalize('./foo/./bar/.')).toBe('foo/bar')
+    })
+
+    it('should handle absolute path', () => {
+      expect(pathUtils.normalize('/foo/bar')).toBe('/foo/bar')
+    })
+
+    it('should return . for empty normalized relative path', () => {
+      expect(pathUtils.normalize('foo/..')).toBe('.')
+    })
+
+    it('should return / for empty normalized absolute path', () => {
+      expect(pathUtils.normalize('/foo/..')).toBe('/')
+    })
+  })
+})

package/tests/unit/runtime-detector.test.ts

@@ -0,0 +1,86 @@
+/**
+ * @file packages/cosmos/tests/unit/runtime-detector.test.ts
+ * @description Runtime detector 單元測試
+ */
+
+import { describe, expect, it } from 'bun:test'
+import { detectRuntime, isEdge, isNode } from '../../src/runtime/detector'
+
+describe('Runtime Detector', () => {
+  it('should detect node runtime', () => {
+    const runtime = detectRuntime()
+    // Bun 環境會被檢測為 node-compatible
+    expect(runtime).toBe('node')
+  })
+
+  it('should return true for isNode()', () => {
+    expect(isNode()).toBe(true)
+  })
+
+  it('should return false for isEdge()', () => {
+    expect(isEdge()).toBe(false)
+  })
+
+  // 以下測試模擬 Edge 環境 (需要 mock globalThis)
+  it('should detect Cloudflare Workers', () => {
+    const originalCaches = globalThis.caches
+    const originalWSP = (globalThis as any).WebSocketPair
+
+    // Mock Cloudflare Workers 環境
+    ;(globalThis as any).caches = {}
+    ;(globalThis as any).WebSocketPair = class {}
+
+    const runtime = detectRuntime()
+
+    // Restore
+    if (originalCaches) {
+      globalThis.caches = originalCaches
+    } else {
+      delete (globalThis as any).caches
+    }
+
+    if (originalWSP) {
+      ;(globalThis as any).WebSocketPair = originalWSP
+    } else {
+      delete (globalThis as any).WebSocketPair
+    }
+
+    expect(runtime).toBe('edge')
+  })
+
+  it('should detect Vercel Edge Runtime', () => {
+    const originalEdgeRuntime = (globalThis as any).EdgeRuntime
+
+    // Mock Vercel Edge Runtime 環境
+    ;(globalThis as any).EdgeRuntime = 'vercel'
+
+    const runtime = detectRuntime()
+
+    // Restore
+    if (originalEdgeRuntime !== undefined) {
+      ;(globalThis as any).EdgeRuntime = originalEdgeRuntime
+    } else {
+      delete (globalThis as any).EdgeRuntime
+    }
+
+    expect(runtime).toBe('edge')
+  })
+
+  it('should detect Deno', () => {
+    const originalDeno = (globalThis as any).Deno
+
+    // Mock Deno 環境
+    ;(globalThis as any).Deno = { version: { deno: '1.0.0' } }
+
+    const runtime = detectRuntime()
+
+    // Restore
+    if (originalDeno !== undefined) {
+      ;(globalThis as any).Deno = originalDeno
+    } else {
+      delete (globalThis as any).Deno
+    }
+
+    expect(runtime).toBe('edge')
+  })
+})