@zhin.js/core 1.0.0 → 1.0.2

package/tests/component-new.test.ts

@@ -0,0 +1,348 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { 
+  defineComponent, 
+  createComponentContext, 
+  renderComponents, 
+  getProps,
+  Component,
+  ComponentContext,
+  Fragment,
+  Fetch
+} from '../src/component'
+import { Message } from '../src/message'
+import { SendOptions } from '../src/types'
+
+// Mock utils functions
+vi.mock('../src/utils', () => ({
+  getValueWithRuntime: vi.fn((expression, context) => {
+    // Simple mock implementation for testing
+    if (typeof expression === 'string' && context) {
+      // Handle simple variable access
+      if (expression in context) {
+        return context[expression]
+      }
+      // Handle object property access like 'user.name'
+      if (expression.includes('.')) {
+        const [obj, prop] = expression.split('.')
+        return context[obj]?.[prop]
+      }
+      // Handle simple expressions
+      try {
+        return eval(expression)
+      } catch {
+        return expression
+      }
+    }
+    return expression
+  }),
+  compiler: vi.fn((template, context) => template),
+  segment: {
+    toString: vi.fn((content) => typeof content === 'string' ? content : JSON.stringify(content)),
+    from: vi.fn((content) => content),
+    escape: vi.fn((content) => content.replace(/</g, '&lt;').replace(/>/g, '&gt;'))
+  }
+}))
+
+describe('函数式组件系统测试', () => {
+  let mockContext: ComponentContext
+  let mockMessage: Message
+
+  beforeEach(() => {
+    mockMessage = {
+      $id: '1',
+      $adapter: 'test',
+      $bot: 'test-bot',
+      $content: [],
+      $sender: { id: 'user1', name: 'User' },
+      $reply: vi.fn(),
+      $channel: { id: 'channel1', type: 'private' },
+      $timestamp: Date.now(),
+      $raw: 'test'
+    }
+
+    mockContext = createComponentContext(
+      { user: { name: 'John', age: 25 } },
+      undefined,
+      'test template'
+    )
+  })
+
+  describe('defineComponent 函数测试', () => {
+    it('应该正确创建函数式组件', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: { name: string }, context: ComponentContext) {
+        return `Hello ${props.name}`
+      }, 'test-component')
+
+      expect(TestComponent).toBeInstanceOf(Function)
+      expect(TestComponent.name).toBe('test-component')
+    })
+
+    it('应该支持异步组件', async () => {
+      const AsyncComponent = defineComponent(async function AsyncComponent(props: { delay: number }, context: ComponentContext) {
+        await new Promise(resolve => setTimeout(resolve, props.delay))
+        return `Delayed: ${props.delay}ms`
+      }, 'async-component')
+
+      const result = await AsyncComponent({ delay: 10 }, mockContext)
+      expect(result).toBe('Delayed: 10ms')
+    })
+  })
+
+  describe('getProps 函数测试', () => {
+    it('应该正确解析简单属性', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test name="John" age={25} active={true} />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.name).toBe('John')
+      expect(props.age).toBe(25)
+      expect(props.active).toBe(true)
+    })
+
+    it('应该正确解析表达式属性', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test sum={1+1} />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.sum).toBe(2)
+    })
+
+    it('应该正确处理 kebab-case 到 camelCase 转换', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test user-name="John" user-age={25} is-active={true} />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.userName).toBe('John')
+      expect(props.userAge).toBe(25)
+      expect(props.isActive).toBe(true)
+    })
+
+    it('应该正确处理 children 属性', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test>Hello World</test>'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.children).toBe('Hello World')
+    })
+
+    it('应该正确处理自闭合标签', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test name="John" />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.name).toBe('John')
+      expect(props.children).toBeUndefined()
+    })
+  })
+
+  describe('createComponentContext 函数测试', () => {
+    it('应该正确创建组件上下文', () => {
+      const context = createComponentContext(
+        { user: { name: 'John' } },
+        undefined,
+        'test template'
+      )
+
+      expect(context.props).toEqual({ user: { name: 'John' } })
+      expect(context.root).toBe('test template')
+      expect(context.parent).toBeUndefined()
+      expect(context.children).toBeUndefined()
+      expect(typeof context.render).toBe('function')
+      expect(typeof context.getValue).toBe('function')
+      expect(typeof context.compile).toBe('function')
+    })
+
+    it('应该正确处理父上下文', () => {
+      const parentContext = createComponentContext({ parent: 'data' })
+      const childContext = createComponentContext(
+        { child: 'data' },
+        parentContext,
+        'child template'
+      )
+
+      expect(childContext.parent).toBe(parentContext)
+      expect(childContext.props).toEqual({ child: 'data' })
+    })
+  })
+
+  describe('内置组件测试', () => {
+    it('Fragment 组件应该正确渲染 children', async () => {
+      const result = await Fragment({ children: 'Hello World' }, mockContext)
+      expect(result).toBe('Hello World')
+    })
+
+    it('Fetch 组件应该正确获取远程内容', async () => {
+      // Mock fetch
+      global.fetch = vi.fn().mockResolvedValue({
+        text: () => Promise.resolve('Remote content')
+      })
+
+      const result = await Fetch({ url: 'https://example.com' }, mockContext)
+      expect(result).toBe('Remote content')
+    })
+  })
+
+  describe('renderComponents 函数测试', () => {
+    it('应该正确渲染单个组件', async () => {
+      const TestComponent = defineComponent(async function TestComponent(props: { name: string }, context: ComponentContext) {
+        return `Hello ${props.name}`
+      }, 'test')
+
+      const componentMap = new Map([['test', TestComponent]])
+      const options: SendOptions = {
+        content: '<test name="John" />',
+        type: 'text',
+        context: 'test',
+        bot: 'test'
+      }
+
+      const result = await renderComponents(componentMap, options)
+      expect(result.content).toContain('Hello John')
+    })
+
+    it('应该正确渲染多个组件', async () => {
+      const Component1 = defineComponent(async function Component1(props: { text: string }, context: ComponentContext) {
+        return `[${props.text}]`
+      }, 'comp1')
+
+      const Component2 = defineComponent(async function Component2(props: { number: number }, context: ComponentContext) {
+        return `{${props.number}}`
+      }, 'comp2')
+
+      const componentMap = new Map([
+        ['comp1', Component1],
+        ['comp2', Component2]
+      ])
+
+      const options: SendOptions = {
+        content: '<comp1 text="Hello" /> <comp2 number={42} />',
+        type: 'text',
+        context: 'test',
+        bot: 'test'
+      }
+
+      const result = await renderComponents(componentMap, options)
+      expect(result.content).toContain('[Hello]')
+      expect(result.content).toContain('{42}')
+    })
+
+    it('应该正确处理嵌套组件', async () => {
+      const OuterComponent = defineComponent(async function OuterComponent(props: { title: string }, context: ComponentContext) {
+        return `标题: ${props.title}`
+      }, 'outer')
+
+      const InnerComponent = defineComponent(async function InnerComponent(props: { content: string }, context: ComponentContext) {
+        return `Content: ${props.content}`
+      }, 'inner')
+
+      const componentMap = new Map([
+        ['outer', OuterComponent],
+        ['inner', InnerComponent]
+      ])
+
+      const options: SendOptions = {
+        content: '<outer title="Test"><inner content="Nested" /></outer>',
+        type: 'text',
+        context: 'test',
+        bot: 'test'
+      }
+
+      const result = await renderComponents(componentMap, options)
+      // 现在嵌套组件渲染应该工作了
+      expect(result.content).toContain('标题: Test')
+    })
+  })
+
+  describe('表达式求值测试', () => {
+    it('应该正确计算数学表达式', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test sum={1+2+3} product={2*3*4} />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.sum).toBe(6)
+      expect(props.product).toBe(24)
+    })
+
+    it('应该正确处理比较表达式', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test greater={5>3} equal={2==2} />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.greater).toBe(true)
+      expect(props.equal).toBe(true)
+    })
+
+    it('应该正确处理三元运算符', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test result={5>3 ? "yes" : "no"} />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.result).toBe('yes')
+    })
+
+    it('应该正确处理数组和对象表达式', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = '<test items={[1,2,3]} config={{name:"test",value:42}} />'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props.items).toEqual([1, 2, 3])
+      expect(props.config).toEqual({ name: 'test', value: 42 })
+    })
+  })
+
+  describe('错误处理测试', () => {
+    it('应该正确处理无效的组件模板', () => {
+      const TestComponent = defineComponent(async function TestComponent(props: any, context: ComponentContext) {
+        return 'test'
+      }, 'test')
+
+      const template = 'invalid template'
+      const props = getProps(TestComponent, template, mockContext)
+
+      expect(props).toEqual({})
+    })
+
+    it('应该正确处理组件渲染错误', async () => {
+      const ErrorComponent = defineComponent(async function ErrorComponent(props: any, context: ComponentContext) {
+        throw new Error('Test error')
+      }, 'error')
+
+      const componentMap = new Map([['error', ErrorComponent]])
+      const options: SendOptions = {
+        content: '<error />',
+        type: 'text',
+        context: 'test',
+        bot: 'test'
+      }
+
+      await expect(renderComponents(componentMap, options)).rejects.toThrow('Test error')
+    })
+  })
+})

package/tests/config.test.ts

@@ -101,7 +101,7 @@ module.exports = {
   ]
 }
 `
-      const configPath = path.join(testDir, 'zhin.config.js')
+      const configPath = path.join(testDir, 'zhin.config.ts')
       fs.writeFileSync(configPath, config)
 
       const [loadedPath, loadedConfig] = await loadConfig({ configPath })

package/tests/errors.test.ts

@@ -0,0 +1,311 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+    ZhinError,
+    ConfigError,
+    PluginError,
+    AdapterError,
+    ConnectionError,
+    MessageError,
+    ContextError,
+    ValidationError,
+    PermissionError,
+    TimeoutError,
+    ErrorManager,
+    RetryManager,
+    CircuitBreaker,
+    errorManager
+} from '../src/errors.js'
+
+describe('错误处理系统', () => {
+    describe('ZhinError基础类', () => {
+        it('应该正确创建基础错误', () => {
+            const error = new ZhinError('测试错误', 'TEST_ERROR', { key: 'value' })
+            
+            expect(error).toBeInstanceOf(Error)
+            expect(error.name).toBe('ZhinError')
+            expect(error.message).toBe('测试错误')
+            expect(error.code).toBe('TEST_ERROR')
+            expect(error.context).toEqual({ key: 'value' })
+            expect(error.timestamp).toBeInstanceOf(Date)
+        })
+
+        it('应该正确转换为JSON', () => {
+            const error = new ZhinError('测试错误', 'TEST_ERROR', { key: 'value' })
+            const json = error.toJSON()
+            
+            expect(json).toEqual({
+                name: 'ZhinError',
+                message: '测试错误',
+                code: 'TEST_ERROR',
+                timestamp: expect.any(String),
+                context: { key: 'value' },
+                stack: expect.any(String)
+            })
+        })
+
+        it('应该正确转换为用户友好格式', () => {
+            const error = new ZhinError('测试错误', 'TEST_ERROR')
+            expect(error.toUserString()).toBe('[TEST_ERROR] 测试错误')
+        })
+    })
+
+    describe('特定错误类型', () => {
+        it('ConfigError应该包含正确信息', () => {
+            const error = new ConfigError('配置无效', { file: 'config.json' })
+            
+            expect(error.code).toBe('CONFIG_ERROR')
+            expect(error.context).toEqual({ file: 'config.json' })
+        })
+
+        it('PluginError应该包含插件信息', () => {
+            const error = new PluginError('插件加载失败', 'test-plugin')
+            
+            expect(error.code).toBe('PLUGIN_ERROR')
+            expect(error.pluginName).toBe('test-plugin')
+            expect(error.context?.pluginName).toBe('test-plugin')
+        })
+
+        it('AdapterError应该包含适配器信息', () => {
+            const error = new AdapterError('适配器连接失败', 'icqq', 'bot-123')
+            
+            expect(error.code).toBe('ADAPTER_ERROR')
+            expect(error.adapterName).toBe('icqq')
+            expect(error.botName).toBe('bot-123')
+        })
+
+        it('ConnectionError应该包含重试信息', () => {
+            const error = new ConnectionError('连接超时', false)
+            
+            expect(error.code).toBe('CONNECTION_ERROR')
+            expect(error.retryable).toBe(false)
+        })
+
+        it('MessageError应该包含消息信息', () => {
+            const error = new MessageError('消息发送失败', 'msg-123', 'channel-456')
+            
+            expect(error.code).toBe('MESSAGE_ERROR')
+            expect(error.messageId).toBe('msg-123')
+            expect(error.channelId).toBe('channel-456')
+        })
+
+        it('ValidationError应该包含验证信息', () => {
+            const error = new ValidationError('字段验证失败', 'username', 'invalid_value')
+            
+            expect(error.code).toBe('VALIDATION_ERROR')
+            expect(error.field).toBe('username')
+            expect(error.value).toBe('invalid_value')
+        })
+
+        it('PermissionError应该包含权限信息', () => {
+            const error = new PermissionError('权限不足', 'user-123', 'admin')
+            
+            expect(error.code).toBe('PERMISSION_ERROR')
+            expect(error.userId).toBe('user-123')
+            expect(error.requiredPermission).toBe('admin')
+        })
+
+        it('TimeoutError应该包含超时信息', () => {
+            const error = new TimeoutError('操作超时', 5000)
+            
+            expect(error.code).toBe('TIMEOUT_ERROR')
+            expect(error.timeoutMs).toBe(5000)
+        })
+    })
+
+    describe('ErrorManager错误管理器', () => {
+        let manager: ErrorManager
+
+        beforeEach(() => {
+            manager = new ErrorManager()
+        })
+
+        it('应该能注册和调用错误处理器', async () => {
+            const handler = vi.fn()
+            const error = new PluginError('测试错误', 'test-plugin')
+            
+            manager.register('PluginError', handler)
+            await manager.handle(error)
+            
+            expect(handler).toHaveBeenCalledWith(error, undefined)
+        })
+
+        it('应该能注册和调用全局处理器', async () => {
+            const handler = vi.fn()
+            const error = new Error('普通错误')
+            
+            manager.registerGlobal(handler)
+            await manager.handle(error)
+            
+            expect(handler).toHaveBeenCalledWith(error, undefined)
+        })
+
+        it('应该能传递上下文信息', async () => {
+            const handler = vi.fn()
+            const error = new Error('测试错误')
+            const context = { key: 'value' }
+            
+            manager.registerGlobal(handler)
+            await manager.handle(error, context)
+            
+            expect(handler).toHaveBeenCalledWith(error, context)
+        })
+
+        it('应该能移除错误处理器', () => {
+            const handler = vi.fn()
+            
+            manager.register('Error', handler)
+            const removed = manager.unregister('Error', handler)
+            
+            expect(removed).toBe(true)
+        })
+
+        it('应该能清理所有处理器', async () => {
+            const handler = vi.fn()
+            const error = new Error('测试错误')
+            
+            manager.registerGlobal(handler)
+            manager.clear()
+            await manager.handle(error)
+            
+            expect(handler).not.toHaveBeenCalled()
+        })
+
+        it('处理器内部错误不应该影响其他处理器', async () => {
+            const failingHandler = vi.fn().mockRejectedValue(new Error('Handler error'))
+            const workingHandler = vi.fn()
+            const error = new Error('测试错误')
+            
+            manager.registerGlobal(failingHandler)
+            manager.registerGlobal(workingHandler)
+            
+            await manager.handle(error)
+            
+            expect(failingHandler).toHaveBeenCalled()
+            expect(workingHandler).toHaveBeenCalled()
+        })
+    })
+
+    describe('RetryManager重试管理器', () => {
+        it('应该在成功时不重试', async () => {
+            const fn = vi.fn().mockResolvedValue('success')
+            
+            const result = await RetryManager.retry(fn, { maxRetries: 3 })
+            
+            expect(result).toBe('success')
+            expect(fn).toHaveBeenCalledTimes(1)
+        })
+
+        it('应该在失败时重试', async () => {
+            const fn = vi.fn()
+                .mockRejectedValueOnce(new Error('第一次失败'))
+                .mockRejectedValueOnce(new Error('第二次失败'))
+                .mockResolvedValue('成功')
+            
+            const result = await RetryManager.retry(fn, { maxRetries: 3, delay: 10 })
+            
+            expect(result).toBe('成功')
+            expect(fn).toHaveBeenCalledTimes(3)
+        })
+
+        it('应该在达到最大重试次数后抛出错误', async () => {
+            const error = new Error('持续失败')
+            const fn = vi.fn().mockRejectedValue(error)
+            
+            await expect(
+                RetryManager.retry(fn, { maxRetries: 2, delay: 10 })
+            ).rejects.toThrow('持续失败')
+            
+            expect(fn).toHaveBeenCalledTimes(3) // 初始调用 + 2次重试
+        })
+
+        it('应该遵循重试条件', async () => {
+            const error = new ConnectionError('不可重试的错误', false)
+            const fn = vi.fn().mockRejectedValue(error)
+            const retryCondition = (err: Error) => err instanceof ConnectionError && (err as ConnectionError).retryable
+            
+            await expect(
+                RetryManager.retry(fn, { maxRetries: 3, retryCondition })
+            ).rejects.toThrow('不可重试的错误')
+            
+            expect(fn).toHaveBeenCalledTimes(1) // 不应该重试
+        })
+
+        it('应该支持指数退避', async () => {
+            const fn = vi.fn()
+                .mockRejectedValueOnce(new Error('失败'))
+                .mockResolvedValue('成功')
+            
+            const startTime = Date.now()
+            await RetryManager.retry(fn, { 
+                maxRetries: 1, 
+                delay: 100, 
+                exponentialBackoff: true 
+            })
+            const endTime = Date.now()
+            
+            // 允许5毫秒的误差范围，因为JavaScript时间精度问题
+            expect(endTime - startTime).toBeGreaterThanOrEqual(95)
+        })
+    })
+
+    describe('CircuitBreaker断路器', () => {
+        let circuitBreaker: CircuitBreaker
+
+        beforeEach(() => {
+            circuitBreaker = new CircuitBreaker(2, 1000, 500) // 失败阈值2, 超时1秒, 监控500ms
+        })
+
+        it('应该在正常情况下执行操作', async () => {
+            const fn = vi.fn().mockResolvedValue('success')
+            
+            const result = await circuitBreaker.execute(fn)
+            
+            expect(result).toBe('success')
+            expect(circuitBreaker.getState()).toBe('CLOSED')
+        })
+
+        it('应该在失败次数达到阈值后打开断路器', async () => {
+            const fn = vi.fn().mockRejectedValue(new Error('失败'))
+            
+            // 第一次失败
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow('失败')
+            expect(circuitBreaker.getState()).toBe('CLOSED')
+            
+            // 第二次失败，应该打开断路器
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow('失败')
+            expect(circuitBreaker.getState()).toBe('OPEN')
+            
+            // 后续调用应该直接拒绝
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow('Circuit breaker is OPEN')
+            expect(fn).toHaveBeenCalledTimes(2) // 不应该再次调用原函数
+        })
+
+        it('应该在超时后尝试半开状态', async () => {
+            const fn = vi.fn().mockRejectedValue(new Error('失败'))
+            
+            // 触发断路器打开
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow()
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow()
+            expect(circuitBreaker.getState()).toBe('OPEN')
+            
+            // 模拟时间过去（这里无法真正等待，但可以测试逻辑）
+            // 在真实场景中，需要等待timeoutMs后再次调用
+        })
+
+        it('应该能重置断路器', async () => {
+            const fn = vi.fn().mockRejectedValue(new Error('失败'))
+            
+            // 触发断路器打开
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow()
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow()
+            expect(circuitBreaker.getState()).toBe('OPEN')
+            
+            // 重置断路器
+            circuitBreaker.reset()
+            expect(circuitBreaker.getState()).toBe('CLOSED')
+            
+            // 应该能再次执行
+            await expect(circuitBreaker.execute(fn)).rejects.toThrow('失败')
+        })
+    })
+})