@zhin.js/core 1.0.38 → 1.0.40

package/tests/utils.test.ts

@@ -1,167 +1,8 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { 
-  compiler, 
-  evaluate, 
-  compose, 
-  segment, 
-  remove, 
-  isEmpty, 
-  Time,
-  clearEvalCache,
-  getEvalCacheStats,
-  execute,
-  getValueWithRuntime,
-  sleep
-} from '../src/utils'
-
-describe('Template Security', () => {
-
-  it('should prevent access to process.env', () => {
-    const template = 'Node env: ${process.env.NODE_ENV}'
-    const result = compiler(template, {})
-    expect(result).toBe('Node env: undefined')
-  })
-
-  it('should prevent access to global object', () => {
-    const template = 'Global: ${global}'
-    const result = compiler(template, {})
-    expect(result).toBe('Global: undefined')
-  })
-
-  it('should prevent access to require function', () => {
-    const template = 'Require: ${require}'
-    const result = compiler(template, {})
-    expect(result).toBe('Require: undefined')
-  })
-
-  it('should allow access to provided context variables', () => {
-    const template = 'Hello ${name}!'
-    const result = compiler(template, { name: 'World' })
-    expect(result).toBe('Hello World!')
-  })
-
-  it('should allow complex expressions with safe context', () => {
-    const template = 'Result: ${Math.max(1, 2, 3)}'
-    const result = compiler(template, {})
-    expect(result).toBe('Result: 3')
-  })
-
-  it('should handle nested object access safely', () => {
-    const template = 'User: ${user.name} (${user.age})'
-    const result = compiler(template, { user: { name: 'Alice', age: 25 } })
-    expect(result).toBe('User: Alice (25)')
-  })
-
-  it('should allow safe Math expressions', () => {
-    const result = evaluate('Math.PI', {})
-    expect(result).toBeCloseTo(3.14159)
-  })
-
-  it('should allow access to safe process properties', () => {
-    const result = evaluate('process.version', {})
-    expect(result).toBe(process.version)
-  })
-
-  it('should block Buffer access', () => {
-    const result = evaluate('Buffer', {})
-    expect(result).toBeUndefined()
-  })
-
-  it('should block crypto access', () => {
-    const result = evaluate('crypto', {})
-    expect(result).toBeUndefined()
-  })
-})
-
-describe('Template Functionality', () => {
-  it('should handle multiple template variables', () => {
-    const template = 'Hello ${name}, you are ${age} years old!'
-    const result = compiler(template, { name: 'Bob', age: 30 })
-    expect(result).toBe('Hello Bob, you are 30 years old!')
-  })
-
-  it('should handle JSON objects in templates', () => {
-    const template = 'Config: ${config}'
-    const config = { debug: true, port: 3000 }
-    const result = compiler(template, { config })
-    expect(result).toBe(`Config: ${JSON.stringify(config, null, 2)}`)
-  })
-
-  it('should handle template expressions that fail gracefully', () => {
-    const template = 'Result: ${undefined.property}'
-    const result = compiler(template, {})
-    // Should return template with undefined when evaluation fails
-    expect(result).toBe('Result: undefined')
-  })
-
-  it('should handle templates without variables', () => {
-    const template = 'Hello World!'
-    const result = compiler(template, {})
-    expect(result).toBe('Hello World!')
-  })
-
-  it('should handle empty template', () => {
-    const template = ''
-    const result = compiler(template, {})
-    expect(result).toBe('')
-  })
-})
-
-describe('evaluate and execute', () => {
-  beforeEach(() => {
-    clearEvalCache()
-  })
-
-  it('should evaluate simple expressions', () => {
-    expect(evaluate('1 + 1', {})).toBe(2)
-    expect(evaluate('2 * 3', {})).toBe(6)
-  })
-
-  it('should return undefined for blocked access', () => {
-    expect(evaluate('global.something', {})).toBeUndefined()
-  })
-
-  it('should use cache for repeated expressions', () => {
-    const expr = '1 + 1'
-    const result1 = execute(expr, {})
-    const result2 = execute(expr, {})
-    expect(result1).toBe(result2)
-    expect(getEvalCacheStats().size).toBe(1)
-  })
-
-  it('should limit cache size', () => {
-    clearEvalCache()
-    // 添加超过 MAX_EVAL_CACHE_SIZE 的表达式
-    for (let i = 0; i < 150; i++) {
-      execute(`1 + ${i}`, {})
-    }
-    const stats = getEvalCacheStats()
-    expect(stats.size).toBeLessThanOrEqual(stats.maxSize)
-  })
-
-  it('should handle invalid expressions gracefully', () => {
-    expect(() => execute('invalid syntax here !!!', {})).toThrow()
-  })
-
-  it('should provide safe process context', () => {
-    const result = execute('return process.platform', {})
-    expect(result).toBe(process.platform)
-  })
-})
-
-describe('getValueWithRuntime', () => {
-  it('should return value from context', () => {
-    expect(getValueWithRuntime('name', { name: 'Alice' })).toBe('Alice')
-  })
-
-  it('should return undefined for blocked access', () => {
-    expect(getValueWithRuntime('global', {})).toBeUndefined()
-  })
-
-  it('should handle complex expressions', () => {
-    expect(getValueWithRuntime('user.name', { user: { name: 'Bob' } })).toBe('Bob')
-  })
-})
+/**
+ * Core 特有的工具函数测试（通用工具测试已迁移到 @zhin.js/kernel）
+ */
+import { describe, it, expect } from 'vitest'
+import { compose, segment } from '../src/utils'
 
 describe('compose middleware', () => {
   it('should return empty function for empty middlewares', async () => {
@@ -219,22 +60,10 @@ describe('compose middleware', () => {
   })
 
   it('should catch and rethrow middleware errors', async () => {
-    const middleware = async (msg: any, next: any) => {
-      throw new Error('Middleware error')
-    }
+    const middleware = async () => { throw new Error('Middleware error') }
     const composed = compose([middleware])
     await expect(composed({} as any, async () => {})).rejects.toThrow('Middleware error')
   })
-
-  it('should call final next function', async () => {
-    let finalCalled = false
-    const middleware = async (msg: any, next: any) => {
-      await next()
-    }
-    const composed = compose([middleware])
-    await composed({} as any, async () => { finalCalled = true })
-    expect(finalCalled).toBe(true)
-  })
 })
 
 describe('segment utilities', () => {
@@ -246,11 +75,6 @@ describe('segment utilities', () => {
     it('should unescape HTML entities', () => {
       expect(segment.unescape('&lt;div&gt;&amp;&quot;&#39;&lt;/div&gt;')).toBe('<div>&"\'</div>')
     })
-
-    it('should handle non-string values', () => {
-      expect(segment.escape(123 as any)).toBe(123)
-      expect(segment.unescape(null as any)).toBe(null)
-    })
   })
 
   describe('text and face', () => {
@@ -259,9 +83,9 @@ describe('segment utilities', () => {
     })
 
     it('should create face segment', () => {
-      expect(segment.face('smile', '😊')).toEqual({ 
-        type: 'face', 
-        data: { id: 'smile', text: '😊' } 
+      expect(segment.face('smile', '😊')).toEqual({
+        type: 'face',
+        data: { id: 'smile', text: '😊' }
       })
     })
   })
@@ -272,83 +96,15 @@ describe('segment utilities', () => {
       expect(result).toEqual([{ type: 'text', data: { text: 'Hello World' } }])
     })
 
-    it('should parse self-closing tags with proper spacing', () => {
+    it('should parse self-closing tags', () => {
       const result = segment.from('<image url="test.jpg" />')
-      expect(result.length).toBeGreaterThan(0)
-      // 检查是否包含 image 类型
-      const imageElement = result.find(el => el.type === 'image')
-      expect(imageElement).toBeDefined()
-    })
-
-    it('should parse paired tags', () => {
-      const result = segment.from('<quote>Hello</quote>')
-      // 检查结果中是否有 quote 元素
-      const quoteElement = result.find(el => el.type === 'quote')
-      expect(quoteElement).toBeDefined()
-    })
-
-    it('should parse mixed content', () => {
-      const result = segment.from('Text <image url="pic.jpg" /> More text')
-      expect(result.length).toBeGreaterThan(0)
-      // 应该包含文本和图片元素
-      expect(result.some(el => el.type === 'text')).toBe(true)
-    })
-
-    it('should handle attributes with single quotes', () => {
-      const result = segment.from("<image url='test.jpg' />")
-      const imageElement = result.find(el => el.type === 'image')
-      expect(imageElement).toBeDefined()
-    })
-
-    it('should handle multiple attributes', () => {
-      const result = segment.from('<image url="test.jpg" width="100" height="200" />')
-      const imageElement = result.find(el => el.type === 'image')
-      // 如果找到了 image 元素，检查它有数据
-      if (imageElement) {
-        expect(imageElement.data).toBeDefined()
-        // 至少应该有一些属性
-        expect(Object.keys(imageElement.data).length).toBeGreaterThanOrEqual(0)
-      } else {
-        // 如果没找到，至少应该有元素被解析
-        expect(result.length).toBeGreaterThan(0)
-      }
-    })
-
-    it('should handle nested tags', () => {
-      const result = segment.from('<quote><text>Hello</text></quote>')
-      // 应该有元素被解析
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    it('should handle array input', () => {
-      const result = segment.from(['Hello', ' ', 'World'])
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    it('should handle MessageElement input', () => {
-      const input = { type: 'text', data: { text: 'Hello' } }
-      const result = segment.from(input)
-      expect(result).toEqual([input])
-    })
-
-    it('should parse JSON values in attributes', () => {
-      const result = segment.from('<data value="123" />')
-      const dataElement = result.find(el => el.type === 'data')
-      // 如果找到了 data 元素，检查值是否被解析
-      if (dataElement && dataElement.data.value !== undefined) {
-        expect(typeof dataElement.data.value).toBe('number')
-      }
+      expect(result.find(el => el.type === 'image')).toBeDefined()
     })
 
     it('should handle malformed templates gracefully', () => {
       const result = segment.from('Hello <unclosed')
       expect(result[0].type).toBe('text')
     })
-
-    it('should handle templates with escaped characters', () => {
-      const result = segment.from('&lt;div&gt;')
-      expect(result[0].data.text).toBe('<div>')
-    })
   })
 
   describe('raw', () => {
@@ -360,11 +116,6 @@ describe('segment utilities', () => {
       expect(segment.raw(content)).toBe('Hello{face}(😊)')
     })
 
-    it('should handle segments without text', () => {
-      const content = [{ type: 'image', data: { url: 'test.jpg' } }]
-      expect(segment.raw(content)).toBe('{image}')
-    })
-
     it('should handle string input', () => {
       expect(segment.raw('Hello')).toBe('Hello')
     })
@@ -379,262 +130,6 @@ describe('segment utilities', () => {
       const result = segment.toString(content)
       expect(result).toContain('Hello')
       expect(result).toContain('<image')
-      expect(result).toContain('url=')
     })
-
-    it('should handle function types', () => {
-      const content = [{ type: function MyType() {} as any, data: { value: 1 } }]
-      const result = segment.toString(content)
-      expect(result).toContain('MyType')
-    })
-
-    it('should escape attribute values', () => {
-      const content = [{ type: 'tag', data: { attr: '<script>' } }]
-      const result = segment.toString(content)
-      expect(result).toContain('&lt;')
-    })
-  })
-})
-
-describe('remove utility', () => {
-  it('should remove item by value', () => {
-    const list = [1, 2, 3, 4]
-    remove(list, 3)
-    expect(list).toEqual([1, 2, 4])
-  })
-
-  it('should remove item by predicate', () => {
-    const list = [1, 2, 3, 4]
-    remove(list, (x) => x > 2)
-    expect(list).toEqual([1, 2, 4])
-  })
-
-  it('should do nothing if item not found', () => {
-    const list = [1, 2, 3]
-    remove(list, 5)
-    expect(list).toEqual([1, 2, 3])
-  })
-
-  it('should handle function items', () => {
-    const fn1 = () => 1
-    const fn2 = () => 2
-    const list = [fn1, fn2]
-    remove(list, fn1)
-    expect(list).toEqual([fn2])
-  })
-})
-
-describe('isEmpty utility', () => {
-  it('should return true for empty array', () => {
-    expect(isEmpty([])).toBe(true)
-  })
-
-  it('should return false for non-empty array', () => {
-    expect(isEmpty([1, 2])).toBe(false)
-  })
-
-  it('should return true for empty object', () => {
-    expect(isEmpty({})).toBe(true)
-  })
-
-  it('should return false for non-empty object', () => {
-    expect(isEmpty({ a: 1 })).toBe(false)
-  })
-
-  it('should return true for null', () => {
-    expect(isEmpty(null)).toBe(true)
-  })
-
-  it('should return false for non-empty values', () => {
-    expect(isEmpty('string')).toBe(false)
-    expect(isEmpty(123)).toBe(false)
-  })
-})
-
-describe('Time utilities', () => {
-  describe('constants', () => {
-    it('should have correct time constants', () => {
-      expect(Time.second).toBe(1000)
-      expect(Time.minute).toBe(60000)
-      expect(Time.hour).toBe(3600000)
-      expect(Time.day).toBe(86400000)
-      expect(Time.week).toBe(604800000)
-    })
-  })
-
-  describe('timezone', () => {
-    it('should get and set timezone offset', () => {
-      const original = Time.getTimezoneOffset()
-      Time.setTimezoneOffset(480)
-      expect(Time.getTimezoneOffset()).toBe(480)
-      Time.setTimezoneOffset(original)
-    })
-  })
-
-  describe('getDateNumber and fromDateNumber', () => {
-    it('should convert date to number and back', () => {
-      const date = new Date('2024-01-01T00:00:00Z')
-      const num = Time.getDateNumber(date, 0)
-      const restored = Time.fromDateNumber(num, 0)
-      expect(restored.getUTCDate()).toBe(date.getUTCDate())
-    })
-
-    it('should handle timestamp input', () => {
-      const timestamp = Date.now()
-      const num = Time.getDateNumber(timestamp)
-      expect(typeof num).toBe('number')
-    })
-  })
-
-  describe('parseTime', () => {
-    it('should parse time strings', () => {
-      expect(Time.parseTime('1d')).toBe(Time.day)
-      expect(Time.parseTime('2h')).toBe(Time.hour * 2)
-      expect(Time.parseTime('30m')).toBe(Time.minute * 30)
-      expect(Time.parseTime('45s')).toBe(Time.second * 45)
-    })
-
-    it('should parse combined time strings', () => {
-      expect(Time.parseTime('1d2h')).toBe(Time.day + Time.hour * 2)
-      expect(Time.parseTime('1w3d')).toBe(Time.week + Time.day * 3)
-    })
-
-    it('should return 0 for invalid strings', () => {
-      expect(Time.parseTime('invalid')).toBe(0)
-      expect(Time.parseTime('')).toBe(0)
-    })
-
-    it('should handle decimal values', () => {
-      expect(Time.parseTime('1.5h')).toBe(Time.hour * 1.5)
-    })
-  })
-
-  describe('parseDate', () => {
-    it('should parse relative time', () => {
-      const now = Date.now()
-      const result = Time.parseDate('1h')
-      expect(result.getTime()).toBeGreaterThan(now)
-    })
-
-    it('should parse time-only format', () => {
-      const result = Time.parseDate('14:30:00')
-      expect(result).toBeInstanceOf(Date)
-    })
-
-    it('should parse short date format', () => {
-      const result = Time.parseDate('12-25-14:30:00')
-      expect(result).toBeInstanceOf(Date)
-    })
-
-    it('should return current date for invalid input', () => {
-      const result = Time.parseDate('')
-      expect(result).toBeInstanceOf(Date)
-    })
-  })
-
-  describe('formatTimeShort', () => {
-    it('should format days', () => {
-      expect(Time.formatTimeShort(Time.day * 2)).toBe('2d')
-    })
-
-    it('should format hours', () => {
-      expect(Time.formatTimeShort(Time.hour * 3)).toBe('3h')
-    })
-
-    it('should format minutes', () => {
-      expect(Time.formatTimeShort(Time.minute * 45)).toBe('45m')
-    })
-
-    it('should format seconds', () => {
-      expect(Time.formatTimeShort(Time.second * 30)).toBe('30s')
-    })
-
-    it('should format milliseconds', () => {
-      expect(Time.formatTimeShort(500)).toBe('500ms')
-    })
-
-    it('should handle negative values', () => {
-      expect(Time.formatTimeShort(-Time.hour * 2)).toBe('-2h')
-    })
-  })
-
-  describe('formatTime', () => {
-    it('should format days with hours', () => {
-      const result = Time.formatTime(Time.day + Time.hour * 3)
-      expect(result).toContain('天')
-      expect(result).toContain('小时')
-    })
-
-    it('should format hours with minutes', () => {
-      const result = Time.formatTime(Time.hour * 2 + Time.minute * 30)
-      expect(result).toContain('小时')
-      expect(result).toContain('分钟')
-    })
-
-    it('should format minutes with seconds', () => {
-      const result = Time.formatTime(Time.minute * 5 + Time.second * 30)
-      expect(result).toContain('分钟')
-      expect(result).toContain('秒')
-    })
-
-    it('should format seconds only', () => {
-      const result = Time.formatTime(Time.second * 30)
-      expect(result).toContain('秒')
-    })
-  })
-
-  describe('template', () => {
-    it('should format date template', () => {
-      const date = new Date('2024-01-15T14:30:45.123')
-      const result = Time.template('yyyy-MM-dd hh:mm:ss', date)
-      expect(result).toBe('2024-01-15 14:30:45')
-    })
-
-    it('should handle short year format', () => {
-      const date = new Date('2024-01-15')
-      const result = Time.template('yy-MM-dd', date)
-      expect(result).toBe('24-01-15')
-    })
-
-    it('should handle milliseconds', () => {
-      const date = new Date('2024-01-15T14:30:45.123')
-      const result = Time.template('SSS', date)
-      expect(result).toBe('123')
-    })
-  })
-
-  describe('formatTimeInterval', () => {
-    it('should format without interval', () => {
-      const date = new Date('2024-01-15T14:30:45')
-      const result = Time.formatTimeInterval(date)
-      expect(result).toContain('2024-01-15')
-    })
-
-    it('should format daily interval', () => {
-      const date = new Date('2024-01-15T14:30:00')
-      const result = Time.formatTimeInterval(date, Time.day)
-      expect(result).toContain('每天')
-    })
-
-    it('should format weekly interval', () => {
-      const date = new Date('2024-01-15T14:30:00')
-      const result = Time.formatTimeInterval(date, Time.week)
-      expect(result).toContain('每周')
-    })
-
-    it('should format custom interval', () => {
-      const date = new Date('2024-01-15T14:30:00')
-      const result = Time.formatTimeInterval(date, Time.hour * 6)
-      expect(result).toContain('每隔')
-    })
-  })
-})
-
-describe('sleep utility', () => {
-  it('should sleep for specified time', async () => {
-    const start = Date.now()
-    await sleep(100)
-    const elapsed = Date.now() - start
-    expect(elapsed).toBeGreaterThanOrEqual(90) // 允许一些误差
   })
 })