@zhin.js/core 1.1.0 → 1.1.3

package/tests/config.test.ts

@@ -1,372 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { ConfigLoader } from '../src/built/config'
-import fs from 'fs'
-import path from 'path'
-
-describe('ConfigLoader', () => {
-  const testConfigPath = path.join(process.cwd(), 'test-config.json')
-  
-  afterEach(() => {
-    // 清理测试文件
-    if (fs.existsSync(testConfigPath)) {
-      fs.unlinkSync(testConfigPath)
-    }
-  })
-
-  describe('Proxy behavior', () => {
-    it('should handle array methods correctly', () => {
-      const config = {
-        items: ['item1', 'item2', 'item3'],
-        bots: [
-          { context: 'sandbox', name: 'bot1' },
-          { context: 'sandbox', name: 'bot2' }
-        ]
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      const proxiedData = loader.data
-      
-      // 测试数组的 map 方法
-      expect(() => {
-        const mapped = proxiedData.items.map((item: string) => item.toUpperCase())
-        expect(mapped).toEqual(['ITEM1', 'ITEM2', 'ITEM3'])
-      }).not.toThrow()
-      
-      // 测试数组的 filter 方法
-      expect(() => {
-        const filtered = proxiedData.bots.filter((bot: any) => bot.name === 'bot1')
-        expect(filtered).toHaveLength(1)
-      }).not.toThrow()
-    })
-
-    it('should handle nested objects', () => {
-      const config = {
-        database: {
-          dialect: 'sqlite',
-          filename: './data/bot.db'
-        },
-        http: {
-          port: 8086,
-          username: '${username}',
-          password: '${password}'
-        }
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      const proxiedData = loader.data
-      
-      expect(proxiedData.database.dialect).toBe('sqlite')
-      expect(proxiedData.http.port).toBe(8086)
-    })
-
-    it('should resolve environment variables', () => {
-      process.env.TEST_VAR = 'test_value'
-      
-      const config = {
-        testValue: '${TEST_VAR}'
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      const proxiedData = loader.data
-      
-      expect(proxiedData.testValue).toBe('test_value')
-      
-      delete process.env.TEST_VAR
-    })
-
-    it('should handle escaped environment variables', () => {
-      const config = {
-        escapedValue: '\\${NOT_A_VAR}'
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      const proxiedData = loader.data
-      
-      expect(proxiedData.escapedValue).toBe('${NOT_A_VAR}')
-    })
-
-    it('should handle default values for missing env vars', () => {
-      const config = {
-        valueWithDefault: '${MISSING_VAR:default_value}'
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      const proxiedData = loader.data
-      
-      expect(proxiedData.valueWithDefault).toBe('default_value')
-    })
-
-    it('should not proxy function properties', () => {
-      const config = {
-        items: [1, 2, 3]
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      const proxiedData = loader.data
-      
-      // 确保数组方法可以正常调用
-      expect(typeof proxiedData.items.map).toBe('function')
-      expect(typeof proxiedData.items.filter).toBe('function')
-      expect(typeof proxiedData.items.reduce).toBe('function')
-    })
-
-    it('should handle Set operations from array', () => {
-      const config = {
-        bots: [
-          { context: 'sandbox', name: 'bot1' },
-          { context: 'process', name: 'bot2' },
-          { context: 'sandbox', name: 'bot3' }
-        ]
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      const proxiedData = loader.data
-      
-      // 模拟 setup.ts 中的操作
-      expect(() => {
-        const contexts = new Set(proxiedData.bots.map((bot: any) => bot.context))
-        expect(contexts.size).toBe(2)
-        expect(contexts.has('sandbox')).toBe(true)
-        expect(contexts.has('process')).toBe(true)
-      }).not.toThrow()
-    })
-  })
-
-  describe('Raw data access', () => {
-    it('should provide raw data without proxy', () => {
-      const config = {
-        value: '${TEST_VAR}'
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      
-      // raw 应该返回原始值，不解析环境变量
-      expect(loader.raw.value).toBe('${TEST_VAR}')
-      
-      // data 应该尝试解析环境变量
-      expect(loader.data.value).toBeTruthy()
-    })
-  })
-
-  describe('File operations', () => {
-    it('should save and load JSON config', () => {
-      const jsonPath = path.join(process.cwd(), 'test-config.json')
-      const config = {
-        name: 'test',
-        value: 123
-      }
-      
-      const loader = new ConfigLoader(jsonPath, config)
-      loader.save(jsonPath)
-      
-      expect(fs.existsSync(jsonPath)).toBe(true)
-      
-      const content = fs.readFileSync(jsonPath, 'utf-8')
-      const parsed = JSON.parse(content)
-      expect(parsed.name).toBe('test')
-      expect(parsed.value).toBe(123)
-      
-      fs.unlinkSync(jsonPath)
-    })
-
-    it('should save and load YAML config', () => {
-      const yamlPath = path.join(process.cwd(), 'test-config.yml')
-      const config = {
-        name: 'test',
-        value: 123
-      }
-      
-      const loader = new ConfigLoader(yamlPath, config)
-      loader.save(yamlPath)
-      
-      expect(fs.existsSync(yamlPath)).toBe(true)
-      
-      fs.unlinkSync(yamlPath)
-    })
-
-    it('should auto-save on property change', () => {
-      const config = {
-        value: 'initial'
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      loader.save(testConfigPath)
-      
-      // 修改属性应该触发自动保存
-      const proxiedData = loader.data
-      proxiedData.value = 'changed'
-      
-      // 重新读取文件验证保存
-      const content = fs.readFileSync(testConfigPath, 'utf-8')
-      const parsed = JSON.parse(content)
-      expect(parsed.value).toBe('changed')
-    })
-
-    it('should auto-save on property deletion', () => {
-      const config = {
-        value: 'test',
-        other: 'keep'
-      }
-      
-      const loader = new ConfigLoader(testConfigPath, config)
-      loader.save(testConfigPath)
-      
-      // 删除属性应该触发自动保存
-      const proxiedData = loader.data as any
-      delete proxiedData.value
-      
-      // 重新读取文件验证保存
-      const content = fs.readFileSync(testConfigPath, 'utf-8')
-      const parsed = JSON.parse(content)
-      expect(parsed.value).toBeUndefined()
-      expect(parsed.other).toBe('keep')
-    })
-  })
-
-  describe('ConfigService', () => {
-    it('should load and cache configs', async () => {
-      const { ConfigService } = await import('../src/built/config')
-      const service = new ConfigService()
-      
-      const config = { test: 'value' }
-      service.load('test-config.json', config)
-      
-      expect(service.configs.has('test-config.json')).toBe(true)
-    })
-
-    it('should throw error for unsupported format', async () => {
-      const { ConfigService } = await import('../src/built/config')
-      const service = new ConfigService()
-      
-      expect(() => {
-        service.load('test.txt', {})
-      }).toThrow('不支持的配置文件格式')
-    })
-
-    it('should get config data', async () => {
-      const { ConfigService } = await import('../src/built/config')
-      const service = new ConfigService()
-      
-      const config = { test: 'value' }
-      service.load(testConfigPath, config)
-      
-      const data = service.get(testConfigPath)
-      expect(data.test).toBe('value')
-    })
-
-    it('should get raw config data', async () => {
-      const { ConfigService } = await import('../src/built/config')
-      const service = new ConfigService()
-      
-      const config = { test: '${VAR}' }
-      service.load(testConfigPath, config)
-      
-      const raw = service.getRaw(testConfigPath)
-      expect(raw.test).toBe('${VAR}')
-    })
-
-    it('should update config data', async () => {
-      const { ConfigService } = await import('../src/built/config')
-      const service = new ConfigService()
-      
-      const config = { test: 'initial' }
-      service.load(testConfigPath, config)
-      
-      service.set(testConfigPath, { test: 'updated' })
-      
-      const data = service.get(testConfigPath)
-      expect(data.test).toBe('updated')
-    })
-
-    it('should throw error when getting non-existent config', async () => {
-      const { ConfigService } = await import('../src/built/config')
-      const service = new ConfigService()
-      
-      service.load(testConfigPath, { test: 'value' })
-      service.configs.delete(testConfigPath) // 手动删除以模拟不存在的情况
-      
-      // 由于 get 会自动加载，我们需要测试 set
-      expect(() => {
-        service.set('non-existent.json', {})
-      }).toThrow('配置文件 non-existent.json 未加载')
-    })
-
-    it('should auto-load config if not cached', async () => {
-      const { ConfigService } = await import('../src/built/config')
-      const service = new ConfigService()
-      
-      const config = { test: 'value' }
-      // 先保存文件
-      const loader = new ConfigLoader(testConfigPath, config)
-      loader.save(testConfigPath)
-      
-      // 不预先加载，直接 get
-      const data = service.get(testConfigPath, config)
-      expect(data.test).toBe('value')
-      expect(service.configs.has(testConfigPath)).toBe(true)
-    })
-  })
-
-  describe('Extension detection', () => {
-    it('should detect .json extension', () => {
-      const loader = new ConfigLoader('config.json', {})
-      expect(loader.extension).toBe('.json')
-    })
-
-    it('should detect .yml extension', () => {
-      const loader = new ConfigLoader('config.yml', {})
-      expect(loader.extension).toBe('.yml')
-    })
-
-    it('should detect .yaml extension', () => {
-      const loader = new ConfigLoader('config.yaml', {})
-      expect(loader.extension).toBe('.yaml')
-    })
-  })
-})
-
-// ============================================================================
-// ConfigFeature 补全测试
-// ============================================================================
-describe('ConfigFeature', () => {
-  let feature: import('../src/built/config.js').ConfigFeature
-
-  beforeEach(async () => {
-    const { ConfigFeature } = await import('../src/built/config.js')
-    feature = new ConfigFeature()
-  })
-
-  it('应有正确的元数据', () => {
-    expect(feature.name).toBe('config')
-    expect(feature.icon).toBe('Settings')
-    expect(feature.desc).toBe('配置')
-  })
-
-  it('add 应添加配置记录', () => {
-    const record = { key: 'debug', defaultValue: false }
-    const dispose = feature.add(record, 'test-plugin')
-    expect(feature.items).toHaveLength(1)
-    expect(feature.items[0]).toBe(record)
-    expect(typeof dispose).toBe('function')
-  })
-
-  it('toJSON 应返回正确结构', () => {
-    feature.add({ key: 'debug', defaultValue: false }, 'test-plugin')
-    feature.add({ key: 'port', defaultValue: 8080 }, 'test-plugin')
-
-    const json = feature.toJSON()
-    expect(json.name).toBe('config')
-    expect(json.count).toBe(2)
-    expect(json.items[0]).toEqual({ name: 'debug' })
-    expect(json.items[1]).toEqual({ name: 'port' })
-  })
-
-  it('toJSON(pluginName) 应按插件过滤', () => {
-    feature.add({ key: 'a', defaultValue: 1 }, 'plugin-a')
-    feature.add({ key: 'b', defaultValue: 2 }, 'plugin-b')
-
-    const json = feature.toJSON('plugin-a')
-    expect(json.count).toBe(1)
-    expect(json.items[0].name).toBe('a')
-  })
-})

package/tests/cron.test.ts

@@ -1,82 +0,0 @@
-/**
- * CronFeature 测试（Cron 类测试已迁移到 @zhin.js/kernel）
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { Cron } from '../src/cron'
-
-describe('CronFeature', () => {
-  let feature: import('../src/built/cron.js').CronFeature
-  let mockCallback: ReturnType<typeof vi.fn>
-
-  beforeEach(async () => {
-    vi.useFakeTimers()
-    mockCallback = vi.fn()
-    const { CronFeature } = await import('../src/built/cron.js')
-    feature = new CronFeature()
-  })
-
-  afterEach(() => {
-    feature?.dispose()
-    vi.useRealTimers()
-  })
-
-  it('add 应自动启动任务', () => {
-    const cron = new Cron('* * * * * *', mockCallback)
-    feature.add(cron, 'test-plugin')
-    expect(cron.running).toBe(true)
-    expect(feature.items).toHaveLength(1)
-  })
-
-  it('add 应返回 dispose 函数', () => {
-    const cron = new Cron('* * * * * *', mockCallback)
-    const dispose = feature.add(cron, 'test-plugin')
-    expect(typeof dispose).toBe('function')
-  })
-
-  it('remove 应自动停止任务', () => {
-    const cron = new Cron('* * * * * *', mockCallback)
-    feature.add(cron, 'test-plugin')
-    feature.remove(cron)
-    expect(cron.running).toBe(false)
-    expect(feature.items).toHaveLength(0)
-  })
-
-  it('stopAll 应停止所有任务', () => {
-    const cron1 = new Cron('* * * * * *', mockCallback)
-    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)
-  })
-
-  it('startAll 应启动所有已停止的任务', () => {
-    const cron1 = new Cron('* * * * * *', mockCallback)
-    const cron2 = new Cron('*/2 * * * * *', mockCallback)
-    feature.add(cron1, 'p1')
-    feature.add(cron2, 'p2')
-    feature.stopAll()
-    feature.startAll()
-    expect(cron1.running).toBe(true)
-    expect(cron2.running).toBe(true)
-  })
-
-  it('toJSON 应返回正确结构', () => {
-    const cron = new Cron('* * * * * *', mockCallback)
-    feature.add(cron, 'test-plugin')
-    const json = feature.toJSON()
-    expect(json.name).toBe('cron')
-    expect(json.icon).toBe('Clock')
-    expect(json.count).toBe(1)
-    expect(json.items[0]).toHaveProperty('expression')
-    expect(json.items[0]).toHaveProperty('running', true)
-  })
-
-  it('dispose 应停止所有任务', () => {
-    const cron = new Cron('* * * * * *', mockCallback)
-    feature.add(cron, 'test-plugin')
-    feature.dispose()
-    expect(cron.running).toBe(false)
-  })
-})