@zhin.js/core 1.0.19 → 1.0.21

package/tests/utils.test.ts

@@ -1,5 +1,18 @@
-import { describe, it, expect } from 'vitest'
-import { compiler, evaluate } from '../src/utils'
+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', () => {
 
@@ -39,14 +52,26 @@ describe('Template Security', () => {
     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', () => {
@@ -68,4 +93,550 @@ describe('Template Functionality', () => {
     // 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', () => {
+    const result = execute('invalid syntax here !!!', {})
+    // 无效表达式会被 try-catch 捕获，返回 undefined
+    expect(result).toBeUndefined()
+  })
+
+  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')
+  })
+})
+
+describe('compose middleware', () => {
+  it('should return empty function for empty middlewares', async () => {
+    const composed = compose([])
+    await expect(composed({} as any, async () => {})).resolves.toBeUndefined()
+  })
+
+  it('should handle single middleware', async () => {
+    let called = false
+    const middleware = async (msg: any, next: any) => {
+      called = true
+      await next()
+    }
+    const composed = compose([middleware])
+    await composed({} as any, async () => {})
+    expect(called).toBe(true)
+  })
+
+  it('should compose multiple middlewares in order', async () => {
+    const order: number[] = []
+    const middleware1 = async (msg: any, next: any) => {
+      order.push(1)
+      await next()
+      order.push(4)
+    }
+    const middleware2 = async (msg: any, next: any) => {
+      order.push(2)
+      await next()
+      order.push(3)
+    }
+    const composed = compose([middleware1, middleware2])
+    await composed({} as any, async () => {})
+    expect(order).toEqual([1, 2, 3, 4])
+  })
+
+  it('should handle middleware execution order correctly', async () => {
+    const order: string[] = []
+    const middleware1 = async (msg: any, next: any) => {
+      order.push('m1-before')
+      await next()
+      order.push('m1-after')
+    }
+    const middleware2 = async (msg: any, next: any) => {
+      order.push('m2-before')
+      await next()
+      order.push('m2-after')
+    }
+    const middleware3 = async (msg: any, next: any) => {
+      order.push('m3')
+      await next()
+    }
+    const composed = compose([middleware1, middleware2, middleware3])
+    await composed({} as any, async () => { order.push('final') })
+    expect(order).toEqual(['m1-before', 'm2-before', 'm3', 'final', 'm2-after', 'm1-after'])
+  })
+
+  it('should catch and rethrow middleware errors', async () => {
+    const middleware = async (msg: any, next: any) => {
+      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', () => {
+  describe('escape and unescape', () => {
+    it('should escape HTML entities', () => {
+      expect(segment.escape('<div>&"\'</div>')).toBe('&lt;div&gt;&amp;&quot;&#39;&lt;/div&gt;')
+    })
+
+    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', () => {
+    it('should create text segment', () => {
+      expect(segment.text('Hello')).toEqual({ type: 'text', data: { text: 'Hello' } })
+    })
+
+    it('should create face segment', () => {
+      expect(segment.face('smile', '😊')).toEqual({ 
+        type: 'face', 
+        data: { id: 'smile', text: '😊' } 
+      })
+    })
+  })
+
+  describe('from', () => {
+    it('should parse simple text', () => {
+      const result = segment.from('Hello World')
+      expect(result).toEqual([{ type: 'text', data: { text: 'Hello World' } }])
+    })
+
+    it('should parse self-closing tags with proper spacing', () => {
+      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')
+      }
+    })
+
+    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', () => {
+    it('should convert segments to raw text', () => {
+      const content = [
+        { type: 'text', data: { text: 'Hello' } },
+        { type: 'face', data: { text: '😊' } },
+      ]
+      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')
+    })
+  })
+
+  describe('toString', () => {
+    it('should convert segments to string', () => {
+      const content = [
+        { type: 'text', data: { text: 'Hello' } },
+        { type: 'image', data: { url: 'test.jpg' } },
+      ]
+      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) // 允许一些误差
+  })
 })