@zhin.js/core 1.0.0

package/tests/adapter.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { Adapter } from '../src/adapter'
+import { Bot } from '../src/bot'
+import { Plugin } from '../src/plugin'
+import { App } from '../src/app'
+import type { BotConfig } from '../src/types'
+
+describe('适配器类测试', () => {
+  // 创建测试用的Bot类
+  class TestBot implements Bot {
+    connected = false
+
+    constructor(public plugin: Plugin, public config: BotConfig) {}
+
+    async connect(): Promise<void> {
+      this.connected = true
+    }
+
+    async disconnect(): Promise<void> {
+      this.connected = false
+    }
+
+    async sendMessage(): Promise<void> {
+      if (!this.connected) throw new Error('机器人未连接')
+    }
+  }
+
+  let app: App
+  let plugin: Plugin
+  let adapter: Adapter<TestBot>
+
+  beforeEach(() => {
+    // 创建测试环境
+    app = new App({
+      bots: [
+        { name: 'test-bot-1', context: 'test-adapter' },
+        { name: 'test-bot-2', context: 'test-adapter' },
+        { name: 'other-bot', context: 'other-adapter' }
+      ]
+    })
+    plugin = app.createDependency('test-plugin', 'test-plugin.ts')
+  })
+
+  describe('构造函数工厂方法测试', () => {
+    it('应该使用构造函数创建适配器', () => {
+      adapter = new Adapter('test-adapter', TestBot)
+      expect(adapter.name).toBe('test-adapter')
+      expect(adapter.bots.size).toBe(0)
+    })
+
+    it('应该使用工厂函数创建适配器', () => {
+      const botFactory = (plugin: Plugin, config: BotConfig) => new TestBot(plugin, config)
+      adapter = new Adapter('test-adapter', botFactory)
+      expect(adapter.name).toBe('test-adapter')
+      expect(adapter.bots.size).toBe(0)
+    })
+  })
+
+  describe('启动和停止测试', () => {
+    beforeEach(() => {
+      adapter = new Adapter('test-adapter', TestBot)
+    })
+
+    it('应该正确启动适配器和机器人', async () => {
+      const loggerSpy = vi.spyOn(plugin.logger, 'info')
+      await adapter.start(plugin)
+
+      expect(adapter.bots.size).toBe(2)
+      expect(adapter.bots.get('test-bot-1')).toBeDefined()
+      expect(adapter.bots.get('test-bot-2')).toBeDefined()
+      expect(adapter.bots.get('test-bot-1')?.connected).toBe(true)
+      expect(adapter.bots.get('test-bot-2')?.connected).toBe(true)
+
+      expect(loggerSpy).toHaveBeenCalledWith('bot test-bot-1 of adapter test-adapter connected')
+      expect(loggerSpy).toHaveBeenCalledWith('bot test-bot-2 of adapter test-adapter connected')
+      expect(loggerSpy).toHaveBeenCalledWith('adapter test-adapter started')
+    })
+
+    it('应该正确停止适配器和机器人', async () => {
+      await adapter.start(plugin)
+      const loggerSpy = vi.spyOn(plugin.logger, 'info')
+      await adapter.stop(plugin)
+
+      expect(adapter.bots.size).toBe(0)
+      expect(loggerSpy).toHaveBeenCalledWith('bot test-bot-1 of adapter test-adapter disconnected')
+      expect(loggerSpy).toHaveBeenCalledWith('bot test-bot-2 of adapter test-adapter disconnected')
+      expect(loggerSpy).toHaveBeenCalledWith('adapter test-adapter stopped')
+    })
+
+    it('没有匹配的机器人配置时应该正常启动', async () => {
+      const emptyAdapter = new Adapter('empty-adapter', TestBot)
+      await emptyAdapter.start(plugin)
+      expect(emptyAdapter.bots.size).toBe(0)
+    })
+  })
+
+  describe('工具函数测试', () => {
+    it('应该正确识别Bot构造函数', () => {
+      // 修改测试用例，因为isBotConstructor返回undefined而不是false
+      expect(Adapter.isBotConstructor(TestBot)).toBe(true)
+      const botFactory = (plugin: Plugin, config: BotConfig) => new TestBot(plugin, config)
+      expect(Adapter.isBotConstructor(botFactory)).toBeFalsy()
+    })
+  })
+
+  describe('错误处理测试', () => {
+    it('应该处理机器人连接失败', async () => {
+      class FailingBot extends TestBot {
+        async connect(): Promise<void> {
+          throw new Error('连接失败')
+        }
+      }
+
+      const failingAdapter = new Adapter('failing-adapter', FailingBot)
+      // 修改配置以包含失败的机器人
+      app.updateConfig({
+        bots: [
+          { name: 'failing-bot', context: 'failing-adapter' }
+        ]
+      })
+      await expect(failingAdapter.start(plugin)).rejects.toThrow('连接失败')
+    })
+
+    it('应该处理机器人断开连接失败', async () => {
+      class FailingBot extends TestBot {
+        async disconnect(): Promise<void> {
+          throw new Error('断开连接失败')
+        }
+      }
+
+      const failingAdapter = new Adapter('failing-adapter', FailingBot)
+      // 修改配置以包含失败的机器人
+      app.updateConfig({
+        bots: [
+          { name: 'failing-bot', context: 'failing-adapter' }
+        ]
+      })
+      await failingAdapter.start(plugin)
+      await expect(failingAdapter.stop(plugin)).rejects.toThrow('断开连接失败')
+    })
+  })
+
+  describe('类型系统测试', () => {
+    it('应该支持扩展的Bot配置', async () => {
+      interface ExtendedBotConfig extends BotConfig {
+        token: string
+        platform: string
+      }
+
+      class ExtendedBot implements Bot<ExtendedBotConfig> {
+        connected = false
+
+        constructor(public plugin: Plugin, public config: ExtendedBotConfig) {}
+
+        async connect(): Promise<void> {
+          this.connected = true
+        }
+
+        async disconnect(): Promise<void> {
+          this.connected = false
+        }
+
+        async sendMessage(): Promise<void> {
+          if (!this.connected) throw new Error('机器人未连接')
+        }
+      }
+
+      const extendedApp = new App({
+        bots: [{
+          name: 'extended-bot',
+          context: 'extended-adapter',
+          token: 'test-token',
+          platform: 'test-platform'
+        }]
+      })
+
+      const extendedPlugin = extendedApp.createDependency('test-plugin', 'test-plugin.ts')
+      const extendedAdapter = new Adapter('extended-adapter', ExtendedBot)
+      await extendedAdapter.start(extendedPlugin)
+
+      const bot = extendedAdapter.bots.get('extended-bot')
+      expect(bot).toBeDefined()
+      expect(bot?.config.token).toBe('test-token')
+      expect(bot?.config.platform).toBe('test-platform')
+    })
+  })
+})

package/tests/app.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { App, createApp } from '../src/app'
+import { AppConfig } from '../src/types'
+import { Plugin } from '../src/plugin'
+import { Adapter } from '../src/adapter'
+import { TestLogger } from './test-utils'
+import path from 'path'
+import fs from 'fs'
+
+describe('App类测试', () => {
+  let app: App
+  let testConfig: AppConfig
+  let testPluginDir: string
+
+  beforeEach(() => {
+    // 设置测试配置
+    testConfig = {
+      plugin_dirs: ['./test-plugins'],
+      plugins: [],
+      bots: [],
+      debug: true
+    }
+
+    // 创建测试插件目录
+    testPluginDir = path.join(process.cwd(), 'test-plugins')
+    if (!fs.existsSync(testPluginDir)) {
+      fs.mkdirSync(testPluginDir, { recursive: true })
+    }
+
+    // 创建App实例
+    app = new App(testConfig)
+  })
+
+  afterEach(async () => {
+    // 停止App
+    await app.stop()
+
+    // 清理测试插件目录
+    if (fs.existsSync(testPluginDir)) {
+      fs.rmSync(testPluginDir, { recursive: true, force: true })
+    }
+  })
+
+  describe('构造函数测试', () => {
+    it('应该使用默认配置创建App实例', () => {
+      const defaultApp = new App()
+      expect(defaultApp.getConfig()).toEqual(App.defaultConfig)
+    })
+
+    it('应该使用自定义配置创建App实例', () => {
+      const config = app.getConfig()
+      expect(config.plugin_dirs).toEqual(['./test-plugins'])
+      expect(config.debug).toBe(true)
+    })
+  })
+
+  describe('配置管理测试', () => {
+    it('应该正确获取配置', () => {
+      const config = app.getConfig()
+      expect(config).toEqual(testConfig)
+    })
+
+    it('应该正确更新配置', () => {
+      const newConfig: Partial<AppConfig> = {
+        debug: false,
+        plugin_dirs: ['./new-plugins']
+      }
+      app.updateConfig(newConfig)
+      const config = app.getConfig()
+      expect(config.debug).toBe(false)
+      expect(config.plugin_dirs).toEqual(['./new-plugins'])
+    })
+  })
+
+  describe('插件管理测试', () => {
+    it('应该正确创建插件依赖', () => {
+      const plugin = app.createDependency('test-plugin', 'test-plugin.ts')
+      expect(plugin).toBeInstanceOf(Plugin)
+      expect(plugin.name).toBe('test-plugin')
+      expect(plugin.filename).toBe('test-plugin.ts')
+    })
+
+    it('应该正确加载插件', async () => {
+      // 创建测试插件文件
+      const pluginPath = path.join(testPluginDir, 'test-plugin.ts')
+      fs.writeFileSync(pluginPath, `
+        import { Plugin } from '@zhin.js/core'
+        export default function(plugin: Plugin) {
+          plugin.logger.info('插件已加载')
+        }
+      `)
+
+      // 更新配置并加载插件
+      app.updateConfig({
+        plugins: [pluginPath]
+      })
+
+      // 启动App
+      await app.start()
+
+      // 验证插件是否被加载
+      const plugin = app.findChild(pluginPath)
+      expect(plugin).toBeDefined()
+      expect(plugin?.isReady).toBe(true)
+    })
+  })
+
+  describe('上下文管理测试', () => {
+    it('应该正确获取上下文', async () => {
+      // 创建测试适配器
+      class TestAdapter extends Adapter {
+        constructor() {
+          super('test-adapter', () => ({} as any))
+        }
+        async start() {}
+        async stop() {}
+      }
+      const adapter = new TestAdapter()
+
+      // 注册适配器
+      const plugin = app.createDependency('test-plugin', 'test-plugin.ts')
+      const context = {
+        name: adapter.name,
+        mounted: () => adapter,
+        dispose: () => {}
+      }
+      plugin.register(context)
+      // 等待插件挂载
+      await plugin.mounted()
+      plugin.useContext('test-adapter',()=>{
+        // 获取上下文
+        const retrievedContext = app.getContext<TestAdapter>('test-adapter')
+        expect(retrievedContext).toBe(adapter)
+      })
+    })
+
+    it('当上下文不存在时应该抛出错误', () => {
+      expect(() => app.getContext('non-existent')).toThrow("can't find Context of non-existent")
+    })
+  })
+
+  describe('消息处理测试', () => {
+    it('应该正确处理发送消息前的钩子', async () => {
+      const options = {
+        id: '123',
+        type: 'group' as const,
+        context: 'test-adapter',
+        bot: 'test-bot',
+        content: '测试消息'
+      }
+
+      const plugin = app.createDependency('test-plugin', 'test-plugin.ts')
+      const handler = vi.fn((opts) => ({
+        ...opts,
+        content: '修改后的消息'
+      }))
+      plugin.on('before-message.send', handler)
+
+      // 触发发送消息事件
+      plugin.emit('before-message.send', options)
+
+      expect(handler).toHaveBeenCalledWith(options)
+    })
+  })
+
+  describe('日志系统测试', () => {
+    it('应该正确创建日志记录器', () => {
+      const logger = app.getLogger('测试', '日志')
+      expect(logger).toBeDefined()
+    })
+  })
+
+  describe('生命周期测试', () => {
+    it('应该正确启动和停止', async () => {
+      const startSpy = vi.spyOn(app, 'start')
+      const stopSpy = vi.spyOn(app, 'stop')
+
+      await app.start()
+      expect(startSpy).toHaveBeenCalled()
+      expect(app.isReady).toBe(true)
+
+      await app.stop()
+      expect(stopSpy).toHaveBeenCalled()
+      expect(app.isDispose).toBe(true)
+    })
+  })
+})
+
+describe('工厂函数测试', () => {
+  it('应该正确创建App实例', async () => {
+    const app = await createApp({
+      debug: true,
+      plugin_dirs: ['./test-plugins']
+    })
+    expect(app).toBeInstanceOf(App)
+    expect(app.getConfig().debug).toBe(true)
+    expect(app.getConfig().plugin_dirs).toEqual(['./test-plugins'])
+    await app.stop()
+  })
+
+  it('应该使用默认配置创建App实例', async () => {
+    const app = await createApp()
+    expect(app).toBeInstanceOf(App)
+    expect(app.getConfig()).toEqual(App.defaultConfig)
+    await app.stop()
+  })
+})

package/tests/bot.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import type { Bot } from '../src/bot'
+import type { BotConfig, SendOptions } from '../src/types'
+
+describe('Bot接口测试', () => {
+  // 创建一个测试用的Bot实现类
+  class TestBot implements Bot {
+    connected = false
+
+    constructor(public config: BotConfig) {}
+
+    async connect(): Promise<void> {
+      this.connected = true
+    }
+
+    async disconnect(): Promise<void> {
+      this.connected = false
+    }
+
+    async sendMessage(options: SendOptions): Promise<void> {
+      if (!this.connected) {
+        throw new Error('机器人未连接')
+      }
+      // 模拟发送消息
+    }
+  }
+
+  let bot: TestBot
+  let testConfig: BotConfig
+
+  beforeEach(() => {
+    testConfig = {
+      name: '测试机器人',
+      context: 'test'
+    }
+    bot = new TestBot(testConfig)
+  })
+
+  describe('基本属性测试', () => {
+    it('应该正确设置配置', () => {
+      expect(bot.config).toEqual(testConfig)
+    })
+
+    it('应该正确初始化连接状态', () => {
+      expect(bot.connected).toBe(false)
+    })
+  })
+
+  describe('连接管理测试', () => {
+    it('应该正确处理连接', async () => {
+      await bot.connect()
+      expect(bot.connected).toBe(true)
+    })
+
+    it('应该正确处理断开连接', async () => {
+      await bot.connect()
+      await bot.disconnect()
+      expect(bot.connected).toBe(false)
+    })
+  })
+
+  describe('消息发送测试', () => {
+    it('未连接时应该抛出错误', async () => {
+      const options: SendOptions = {
+        id: '123',
+        type: 'group',
+        context: 'test',
+        bot: 'test-bot',
+        content: '测试消息'
+      }
+
+      await expect(bot.sendMessage(options)).rejects.toThrow('机器人未连接')
+    })
+
+    it('连接后应该正确发送消息', async () => {
+      const options: SendOptions = {
+        id: '123',
+        type: 'group',
+        context: 'test',
+        bot: 'test-bot',
+        content: '测试消息'
+      }
+
+      const sendSpy = vi.spyOn(bot, 'sendMessage')
+      await bot.connect()
+      await bot.sendMessage(options)
+      expect(sendSpy).toHaveBeenCalledWith(options)
+    })
+  })
+
+  describe('自定义配置测试', () => {
+    it('应该支持扩展的配置类型', () => {
+      interface ExtendedConfig extends BotConfig {
+        token: string
+        platform: string
+      }
+
+      class ExtendedBot implements Bot<ExtendedConfig> {
+        connected = false
+
+        constructor(public config: ExtendedConfig) {}
+
+        async connect(): Promise<void> {
+          this.connected = true
+        }
+
+        async disconnect(): Promise<void> {
+          this.connected = false
+        }
+
+        async sendMessage(options: SendOptions): Promise<void> {
+          if (!this.connected) {
+            throw new Error('机器人未连接')
+          }
+          // 模拟发送消息
+        }
+      }
+
+      const extendedConfig: ExtendedConfig = {
+        name: '扩展机器人',
+        context: 'extended',
+        token: 'test-token',
+        platform: 'test-platform'
+      }
+
+      const extendedBot = new ExtendedBot(extendedConfig)
+      expect(extendedBot.config).toEqual(extendedConfig)
+      expect(extendedBot.config.token).toBe('test-token')
+      expect(extendedBot.config.platform).toBe('test-platform')
+    })
+  })
+})