@zhin.js/core 1.0.38 → 1.0.40

package/tests/cron.test.ts

@@ -1,302 +1,9 @@
+/**
+ * CronFeature 测试（Cron 类测试已迁移到 @zhin.js/kernel）
+ */
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import { Cron } from '../src/cron'
 
-describe('Cron定时任务系统测试', () => {
-  let mockCallback: () => void | Promise<void>
-  let cron: Cron
-
-  beforeEach(() => {
-    vi.useFakeTimers()
-    mockCallback = vi.fn()
-  })
-
-  afterEach(() => {
-    if (cron && !cron.disposed) {
-      cron.dispose()
-    }
-    vi.useRealTimers()
-  })
-
-  describe('Cron实例化', () => {
-    it('应该正确创建Cron实例', () => {
-      cron = new Cron('0 0 * * * *', mockCallback) // 每小时执行
-      expect(cron).toBeInstanceOf(Cron)
-      expect(cron.running).toBe(false)
-      expect(cron.disposed).toBe(false)
-    })
-
-    it('应该正确保存cron表达式', () => {
-      cron = new Cron('0 0 12 * * *', mockCallback) // 每天中午12点
-      expect(cron.cronExpression).toContain('0 12 * * *')
-    })
-
-    it('应该拒绝无效的cron表达式', () => {
-      expect(() => {
-        new Cron('invalid expression', mockCallback)
-      }).toThrow(/Invalid cron expression/)
-    })
-
-    it('应该接受异步回调函数', () => {
-      const asyncCallback = vi.fn().mockResolvedValue(undefined)
-      cron = new Cron('0 0 * * * *', asyncCallback)
-      expect(cron).toBeInstanceOf(Cron)
-    })
-  })
-
-  describe('任务执行控制', () => {
-    beforeEach(() => {
-      cron = new Cron('*/5 * * * * *', mockCallback) // 每5秒执行
-    })
-
-    it('应该能够启动任务', () => {
-      expect(cron.running).toBe(false)
-      cron.run()
-      expect(cron.running).toBe(true)
-    })
-
-    it('应该能够停止任务', () => {
-      cron.run()
-      expect(cron.running).toBe(true)
-      cron.stop()
-      expect(cron.running).toBe(false)
-    })
-
-    it('应该防止重复启动', () => {
-      cron.run()
-      expect(cron.running).toBe(true)
-      
-      // 第二次调用run应该无效果
-      cron.run()
-      expect(cron.running).toBe(true)
-    })
-
-    it('应该能够销毁任务', () => {
-      cron.run()
-      expect(cron.running).toBe(true)
-      expect(cron.disposed).toBe(false)
-      
-      cron.dispose()
-      expect(cron.running).toBe(false)
-      expect(cron.disposed).toBe(true)
-    })
-
-    it('应该拒绝操作已销毁的任务', () => {
-      cron.dispose()
-      expect(() => cron.run()).toThrow(/Cannot run a disposed cron job/)
-      expect(() => cron.getNextExecutionTime()).toThrow(/Cannot get next execution time for a disposed cron job/)
-    })
-  })
-
-  describe('时间计算', () => {
-    beforeEach(() => {
-      // 设置固定时间: 2024-01-01 00:00:00
-      vi.setSystemTime(new Date('2024-01-01T00:00:00.000Z'))
-    })
-
-    it('应该计算下一次执行时间', () => {
-      cron = new Cron('0 0 12 * * *', mockCallback) // 每天中午12点
-      const nextTime = cron.getNextExecutionTime()
-      
-      // 下一次执行应该是当天中午12点
-      expect(nextTime.getHours()).toBe(12)
-      expect(nextTime.getMinutes()).toBe(0)
-      expect(nextTime.getSeconds()).toBe(0)
-    })
-
-    it('应该处理跨日期的执行时间', () => {
-      vi.setSystemTime(new Date('2024-01-01T23:00:00.000Z')) // 晚上11点
-      cron = new Cron('0 0 1 * * *', mockCallback) // 每天凌晨1点
-      
-      const nextTime = cron.getNextExecutionTime()
-      // 从晚上11点到第二天凌晨1点，可能还是当天或第二天，取决于实现
-      expect(nextTime.getHours()).toBe(1)
-      expect(nextTime.getDate()).toBeGreaterThanOrEqual(1)
-    })
-  })
-
-  describe('cron表达式解析', () => {
-    it('应该支持每分钟执行', () => {
-      cron = new Cron('0 * * * * *', mockCallback)
-      expect(cron.cronExpression).toContain('* * * * *')
-    })
-
-    it('应该支持每小时执行', () => {
-      cron = new Cron('0 0 * * * *', mockCallback)
-      expect(cron.cronExpression).toContain('0 * * * *')
-    })
-
-    it('应该支持每天执行', () => {
-      cron = new Cron('0 0 0 * * *', mockCallback)
-      expect(cron.cronExpression).toContain('0 0 * * *')
-    })
-
-    it('应该支持步长表达式', () => {
-      cron = new Cron('0 */15 * * * *', mockCallback) // 每15分钟
-      expect(cron.cronExpression).toContain('*/15')
-    })
-
-    it('应该支持范围表达式', () => {
-      cron = new Cron('0 0 9-17 * * *', mockCallback) // 工作时间
-      expect(cron.cronExpression).toContain('9-17')
-    })
-
-    it('应该支持列表表达式', () => {
-      cron = new Cron('0 0 0 * * 1,3,5', mockCallback) // 周一、三、五
-      expect(cron.cronExpression).toContain('1,3,5')
-    })
-  })
-
-  describe('任务执行', () => {
-    it('应该在指定时间执行回调', async () => {
-      // 每秒执行的任务
-      cron = new Cron('* * * * * *', mockCallback)
-      cron.run()
-
-      // 推进时间1秒
-      await vi.advanceTimersByTimeAsync(1000)
-      
-      expect(mockCallback).toHaveBeenCalledTimes(1)
-    })
-
-    it('应该处理异步回调', async () => {
-      const asyncCallback = vi.fn().mockResolvedValue(undefined)
-      cron = new Cron('* * * * * *', asyncCallback)
-      cron.run()
-
-      await vi.advanceTimersByTimeAsync(1000)
-      
-      expect(asyncCallback).toHaveBeenCalledTimes(1)
-    })
-
-    it('应该处理回调中的错误', async () => {
-      const errorCallback = vi.fn().mockRejectedValue(new Error('Test error'))
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      
-      cron = new Cron('* * * * * *', errorCallback)
-      cron.run()
-
-      await vi.advanceTimersByTimeAsync(1000)
-      
-      expect(errorCallback).toHaveBeenCalledTimes(1)
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Error executing cron callback')
-      )
-      
-      consoleErrorSpy.mockRestore()
-    })
-
-    it('应该继续执行即使回调出错', async () => {
-      const errorCallback = vi.fn()
-        .mockRejectedValueOnce(new Error('First error'))
-        .mockResolvedValueOnce(undefined)
-      
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      
-      cron = new Cron('* * * * * *', errorCallback)
-      cron.run()
-
-      // 第一次执行（出错）
-      await vi.advanceTimersByTimeAsync(1000)
-      expect(errorCallback).toHaveBeenCalledTimes(1)
-      
-      // 第二次执行（成功）
-      await vi.advanceTimersByTimeAsync(1000)
-      expect(errorCallback).toHaveBeenCalledTimes(2)
-      
-      consoleErrorSpy.mockRestore()
-    })
-  })
-
-  describe('定时器管理', () => {
-    it('应该在停止时清除定时器', () => {
-      cron = new Cron('0 0 * * * *', mockCallback)
-      cron.run()
-      
-      const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout')
-      cron.stop()
-      
-      expect(clearTimeoutSpy).toHaveBeenCalled()
-      clearTimeoutSpy.mockRestore()
-    })
-
-    it('应该在销毁时清除定时器', () => {
-      cron = new Cron('0 0 * * * *', mockCallback)
-      cron.run()
-      
-      const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout')
-      cron.dispose()
-      
-      expect(clearTimeoutSpy).toHaveBeenCalled()
-      clearTimeoutSpy.mockRestore()
-    })
-  })
-
-  describe('边界情况', () => {
-    it('应该处理立即执行的情况', async () => {
-      // 设置当前时间为准确的秒开始
-      vi.setSystemTime(new Date('2024-01-01T00:00:00.000Z'))
-      
-      cron = new Cron('* * * * * *', mockCallback) // 每秒执行
-      cron.run()
-      
-      // 只推进1秒，避免无限循环
-      await vi.advanceTimersByTimeAsync(1000)
-      
-      expect(mockCallback).toHaveBeenCalled()
-    })
-
-    it('应该处理非常频繁的任务', async () => {
-      // 每秒执行多次的任务（这在实际使用中可能不常见，但测试边界情况）
-      cron = new Cron('* * * * * *', mockCallback)
-      cron.run()
-
-      // 推进5秒
-      for (let i = 0; i < 5; i++) {
-        await vi.advanceTimersByTimeAsync(1000)
-      }
-      
-      expect(mockCallback).toHaveBeenCalledTimes(5)
-    })
-
-    it('应该在停止后不再执行', async () => {
-      cron = new Cron('* * * * * *', mockCallback)
-      cron.run()
-
-      // 推进1秒并执行
-      await vi.advanceTimersByTimeAsync(1000)
-      expect(mockCallback).toHaveBeenCalledTimes(1)
-      
-      // 停止任务
-      cron.stop()
-      
-      // 再推进时间，不应该再执行
-      await vi.advanceTimersByTimeAsync(2000)
-      expect(mockCallback).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('Cron错误处理', () => {
-    it('should throw error for truly invalid cron expression', () => {
-      // 完全无效的 cron 表达式应该抛出错误
-      expect(() => {
-        cron = new Cron('not a valid cron', mockCallback)
-        cron.run()
-      }).toThrow()
-    })
-
-    it('should accept edge-case cron expression like Feb 30 without throwing', () => {
-      // 2月30日虽然不存在，但 cron 库接受该表达式（不会抛错）
-      expect(() => {
-        cron = new Cron('0 0 30 2 *', mockCallback)
-        cron.run()
-      }).not.toThrow()
-    })
-  })
-})
-
-// ============================================================================
-// CronFeature 补全测试
-// ============================================================================
 describe('CronFeature', () => {
   let feature: import('../src/built/cron.js').CronFeature
   let mockCallback: ReturnType<typeof vi.fn>
@@ -339,7 +46,6 @@ describe('CronFeature', () => {
     const cron2 = new Cron('*/2 * * * * *', mockCallback)
     feature.add(cron1, 'p1')
     feature.add(cron2, 'p2')
-
     feature.stopAll()
     expect(cron1.running).toBe(false)
     expect(cron2.running).toBe(false)
@@ -351,7 +57,6 @@ describe('CronFeature', () => {
     feature.add(cron1, 'p1')
     feature.add(cron2, 'p2')
     feature.stopAll()
-
     feature.startAll()
     expect(cron1.running).toBe(true)
     expect(cron2.running).toBe(true)
@@ -374,4 +79,4 @@ describe('CronFeature', () => {
     feature.dispose()
     expect(cron.running).toBe(false)
   })
-})
+})

package/tests/errors.test.ts

@@ -1,311 +1,21 @@
-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)
-        })
+/**
+ * Core 特有的错误类型测试（通用错误测试已迁移到 @zhin.js/kernel）
+ */
+import { describe, it, expect } from 'vitest'
+import { AdapterError, MessageError } from '../src/errors.js'
+
+describe('Core 特有错误类型', () => {
+    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')
     })
 
-    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('失败')
-        })
+    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')
     })
 })