@zhin.js/core 1.1.0 → 1.1.2

package/tests/prompt.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { Prompt } from '../src/prompt'
-import { Plugin } from '../src/plugin'
-import { Schema } from '@zhin.js/schema'
-
-describe('Prompt', () => {
-  let plugin: Plugin
-  let mockEvent: any
-  let prompt: Prompt<any>
-
-  beforeEach(() => {
-    plugin = new Plugin('/test/plugin.ts')
-    
-    // 创建模拟事件
-    mockEvent = {
-      $adapter: 'test-adapter',
-      $bot: 'test-bot',
-      $channel: { type: 'text', id: 'test-channel' },
-      $sender: { id: 'test-user' },
-      $raw: 'test message',
-      $reply: vi.fn().mockResolvedValue('message-id')
-    }
-
-    prompt = new Prompt(plugin, mockEvent as any)
-  })
-
-  describe('Constructor', () => {
-    it('should create Prompt instance', () => {
-      expect(prompt).toBeInstanceOf(Prompt)
-    })
-  })
-
-  describe('const', () => {
-    it('should return constant value', async () => {
-      const result = await prompt.const(42)
-      expect(result).toBe(42)
-    })
-
-    it('should return constant string', async () => {
-      const result = await prompt.const('test-value')
-      expect(result).toBe('test-value')
-    })
-
-    it('should return constant object', async () => {
-      const obj = { key: 'value' }
-      const result = await prompt.const(obj)
-      expect(result).toBe(obj)
-    })
-
-    it('should return constant array', async () => {
-      const arr = [1, 2, 3]
-      const result = await prompt.const(arr)
-      expect(result).toBe(arr)
-    })
-  })
-
-  describe('Schema error handling', () => {
-    it('should throw error for unsupported list inner type', async () => {
-      const schema = Schema.list(Schema.object({})).description('不支持的列表类型')
-      
-      await expect(prompt.getValueWithSchema(schema)).rejects.toThrow('unsupported inner type')
-    })
-
-    it('should throw error for unsupported schema type', async () => {
-      const schema = Schema.dict(Schema.string()).description('不支持的类型')
-      
-      await expect(prompt.getValueWithSchema(schema)).rejects.toThrow('Unsupported schema input type')
-    })
-
-    it('should throw error for object schema without object definition', async () => {
-      const schema = Schema.object({})
-      // 删除 object 定义来触发错误
-      delete (schema as any).options.object
-      
-      await expect(prompt.getValueWithSchema(schema)).rejects.toThrow('Object schema missing object definition')
-    })
-  })
-})

package/tests/redos-protection.test.ts

@@ -1,198 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { segment } from '../src/utils.js';
-
-describe('ReDoS Protection Tests', () => {
-  describe('segment.from() ReDoS protection', () => {
-    it('should handle small inputs (100 attributes) without timeout', () => {
-      // 测试少量属性的标签
-      const smallInput = '<tag ' + 'a="b" '.repeat(100) + '/>';
-      const start = Date.now();
-      
-      try {
-        segment.from(smallInput);
-        const duration = Date.now() - start;
-        
-        // 应该在合理时间内完成（100ms）
-        expect(duration).toBeLessThan(100);
-      } catch (error) {
-        // 如果抛出错误，也是可以接受的（比如输入太大）
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should handle medium inputs (500 attributes) without timeout', () => {
-      // 测试中等数量属性的标签
-      const mediumInput = '<tag ' + 'a="b" '.repeat(500) + '/>';
-      const start = Date.now();
-      
-      try {
-        segment.from(mediumInput);
-        const duration = Date.now() - start;
-        
-        // 应该在合理时间内完成（500ms）
-        expect(duration).toBeLessThan(500);
-      } catch (error) {
-        // 如果抛出错误，也是可以接受的（比如输入太大）
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should handle large inputs (1000 attributes) without timeout', () => {
-      // 测试大量属性的标签
-      const largeInput = '<tag ' + 'a="b" '.repeat(1000) + '/>';
-      const start = Date.now();
-      
-      try {
-        segment.from(largeInput);
-        const duration = Date.now() - start;
-        
-        // 应该在合理时间内完成（1秒）
-        expect(duration).toBeLessThan(1000);
-      } catch (error) {
-        // 如果抛出错误，也是可以接受的（比如输入太大）
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should handle very large inputs (2000 attributes) without timeout', () => {
-      // 测试更大量属性的标签
-      const veryLargeInput = '<tag ' + 'a="b" '.repeat(2000) + '/>';
-      const start = Date.now();
-      
-      try {
-        segment.from(veryLargeInput);
-        const duration = Date.now() - start;
-        
-        // 应该在合理时间内完成（2秒）
-        expect(duration).toBeLessThan(2000);
-      } catch (error) {
-        // 如果抛出错误，也是可以接受的（比如输入太大）
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should reject extremely large templates', () => {
-      // segment.from 在 utils 中限制单段模板长度 > 400_000（见 MAX_TEMPLATE_LENGTH）
-      const chunk = '<tag>content</tag>';
-      const hugeTemplate = chunk.repeat(Math.ceil(400_001 / chunk.length));
-
-      expect(() => {
-        segment.from(hugeTemplate);
-      }).toThrow(/Template too large/);
-    });
-
-    it('should handle nested tags without exponential backtracking', () => {
-      // 测试嵌套标签
-      const nestedInput = '<outer ' + 'attr="val" '.repeat(100) + '><inner>text</inner></outer>';
-      const start = Date.now();
-      
-      segment.from(nestedInput);
-      const duration = Date.now() - start;
-      
-      // 应该在合理时间内完成
-      expect(duration).toBeLessThan(500);
-    });
-
-    it('should handle malformed attributes gracefully', () => {
-      // 测试格式错误的属性
-      const malformedInput = '<tag a=b c=d e="f"/>';
-      
-      // 不应该崩溃或超时
-      const start = Date.now();
-      const result = segment.from(malformedInput);
-      const duration = Date.now() - start;
-      
-      expect(duration).toBeLessThan(100);
-      expect(result).toBeDefined();
-    });
-
-    it('should prevent infinite loops', () => {
-      // 测试可能导致无限循环的输入
-      const problematicInput = '<tag><tag><tag><tag><tag>';
-      
-      const start = Date.now();
-      try {
-        segment.from(problematicInput);
-      } catch (error) {
-        // 可能会抛出错误，这是可以接受的
-      }
-      const duration = Date.now() - start;
-      
-      // 应该在合理时间内完成或失败
-      expect(duration).toBeLessThan(1000);
-    });
-
-    it('should handle complex attribute patterns', () => {
-      // 测试复杂的属性模式
-      const complexInput = '<tag attr1="value1" attr2=\'value2\' attr3="value with spaces"/>';
-      
-      const start = Date.now();
-      const result = segment.from(complexInput);
-      const duration = Date.now() - start;
-      
-      expect(duration).toBeLessThan(100);
-      expect(Array.isArray(result)).toBe(true);
-    });
-
-    it('should handle repeated patterns efficiently', () => {
-      // 测试重复模式
-      const repeatedPattern = ('<tag attr="value">content</tag>').repeat(100);
-      
-      const start = Date.now();
-      try {
-        segment.from(repeatedPattern);
-      } catch (error) {
-        // 如果输入太大，抛出错误是可以接受的
-      }
-      const duration = Date.now() - start;
-      
-      expect(duration).toBeLessThan(1000);
-    });
-
-    it('should handle edge cases with special characters', () => {
-      // 测试特殊字符
-      const specialChars = '<tag attr="value with \\"quotes\\" and \'apostrophes\'">content</tag>';
-      
-      const start = Date.now();
-      const result = segment.from(specialChars);
-      const duration = Date.now() - start;
-      
-      expect(duration).toBeLessThan(100);
-      expect(Array.isArray(result)).toBe(true);
-    });
-  });
-
-  describe('Normal functionality should still work', () => {
-    it('should parse simple self-closing tags', () => {
-      const input = '<image url="test.jpg"/>';
-      const result = segment.from(input);
-      
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBeGreaterThan(0);
-    });
-
-    it('should parse tags with content', () => {
-      const input = '<text>Hello World</text>';
-      const result = segment.from(input);
-      
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBeGreaterThan(0);
-    });
-
-    it('should parse tags with attributes', () => {
-      const input = '<at id="123" name="user"/>';
-      const result = segment.from(input);
-      
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBeGreaterThan(0);
-    });
-
-    it('should parse nested tags', () => {
-      const input = '<quote><text>quoted text</text></quote>';
-      const result = segment.from(input);
-      
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBeGreaterThan(0);
-    });
-  });
-});

package/tests/request.test.ts

@@ -1,221 +0,0 @@
-/**
- * Request 抽象层测试
- */
-import { Request, RequestBase, RequestType } from '../src/request.js';
-
-describe('Request', () => {
-  // ============================================================================
-  // Request.from()
-  // ============================================================================
-  describe('Request.from()', () => {
-    it('应合并原始数据与基础结构', () => {
-      const raw = { flag: 'abc123', extra_data: 42 };
-      const base: RequestBase = {
-        $id: 'req_001',
-        $adapter: 'onebot11' as any,
-        $bot: 'bot1',
-        $type: 'friend_add',
-        $channel: { id: '100', type: 'private' },
-        $sender: { id: '200', name: '请求者' },
-        $comment: '请加我好友',
-        $timestamp: 1000,
-        $approve: async () => {},
-        $reject: async () => {},
-      };
-      const request = Request.from(raw, base);
-
-      expect(request.$id).toBe('req_001');
-      expect(request.$adapter).toBe('onebot11');
-      expect(request.$bot).toBe('bot1');
-      expect(request.$type).toBe('friend_add');
-      expect(request.$channel.type).toBe('private');
-      expect(request.$sender).toEqual({ id: '200', name: '请求者' });
-      expect(request.$comment).toBe('请加我好友');
-      expect(request.$timestamp).toBe(1000);
-      // 原始字段保留
-      expect(request.flag).toBe('abc123');
-      expect(request.extra_data).toBe(42);
-    });
-
-    it('$comment 和 $subType 应可以为 undefined', () => {
-      const request = Request.from({}, {
-        $id: 'req_002',
-        $adapter: 'icqq' as any,
-        $bot: 'bot1',
-        $type: 'group_add',
-        $channel: { id: '300', type: 'group' },
-        $sender: { id: '400', name: '申请者' },
-        $timestamp: 2000,
-        $approve: async () => {},
-        $reject: async () => {},
-      });
-
-      expect(request.$comment).toBeUndefined();
-      expect(request.$subType).toBeUndefined();
-    });
-  });
-
-  // ============================================================================
-  // $approve / $reject
-  // ============================================================================
-  describe('$approve() 和 $reject()', () => {
-    it('调用 $approve 应执行同意逻辑', async () => {
-      let approved = false;
-      let approveRemark: string | undefined;
-      const request = Request.from({}, {
-        $id: 'req_approve',
-        $adapter: 'onebot11' as any,
-        $bot: 'bot1',
-        $type: 'friend_add',
-        $channel: { id: '100', type: 'private' },
-        $sender: { id: '200', name: '用户' },
-        $timestamp: 0,
-        $approve: async (remark?: string) => {
-          approved = true;
-          approveRemark = remark;
-        },
-        $reject: async () => {},
-      });
-
-      await request.$approve('备注名');
-      expect(approved).toBe(true);
-      expect(approveRemark).toBe('备注名');
-    });
-
-    it('调用 $reject 应执行拒绝逻辑', async () => {
-      let rejected = false;
-      let rejectReason: string | undefined;
-      const request = Request.from({}, {
-        $id: 'req_reject',
-        $adapter: 'onebot11' as any,
-        $bot: 'bot1',
-        $type: 'group_invite',
-        $channel: { id: '300', type: 'group' },
-        $sender: { id: '400', name: '邀请者' },
-        $timestamp: 0,
-        $approve: async () => {},
-        $reject: async (reason?: string) => {
-          rejected = true;
-          rejectReason = reason;
-        },
-      });
-
-      await request.$reject('不接受邀请');
-      expect(rejected).toBe(true);
-      expect(rejectReason).toBe('不接受邀请');
-    });
-
-    it('$approve 无参数调用应不报错', async () => {
-      let called = false;
-      const request = Request.from({}, {
-        $id: 'req_noarg',
-        $adapter: 'onebot11' as any,
-        $bot: 'bot1',
-        $type: 'friend_add',
-        $channel: { id: '1', type: 'private' },
-        $sender: { id: '2', name: 'user' },
-        $timestamp: 0,
-        $approve: async () => { called = true; },
-        $reject: async () => {},
-      });
-
-      await request.$approve();
-      expect(called).toBe(true);
-    });
-  });
-
-  // ============================================================================
-  // RequestType
-  // ============================================================================
-  describe('RequestType', () => {
-    it('应接受所有预定义类型', () => {
-      const types: RequestType[] = ['friend_add', 'group_add', 'group_invite'];
-      expect(types).toHaveLength(3);
-    });
-
-    it('应接受自定义扩展类型', () => {
-      const customType: RequestType = 'custom_request_type';
-      expect(customType).toBe('custom_request_type');
-    });
-  });
-
-  // ============================================================================
-  // 典型场景
-  // ============================================================================
-  describe('典型场景', () => {
-    it('好友添加请求', async () => {
-      let approvedFlag: string | undefined;
-      const raw = { flag: 'friend_flag_001', user_id: 12345 };
-      const request = Request.from(raw, {
-        $id: 'friend_flag_001',
-        $adapter: 'onebot11' as any,
-        $bot: 'mybot',
-        $type: 'friend_add',
-        $subType: 'add',
-        $channel: { id: '12345', type: 'private' },
-        $sender: { id: '12345', name: '新朋友' },
-        $comment: '你好，加个好友吧',
-        $timestamp: Date.now(),
-        $approve: async (remark?: string) => {
-          approvedFlag = raw.flag;
-        },
-        $reject: async () => {},
-      });
-
-      expect(request.$type).toBe('friend_add');
-      expect(request.$comment).toBe('你好，加个好友吧');
-      expect(request.flag).toBe('friend_flag_001');
-      expect(request.user_id).toBe(12345);
-
-      await request.$approve();
-      expect(approvedFlag).toBe('friend_flag_001');
-    });
-
-    it('入群申请', async () => {
-      let rejected = false;
-      const raw = { flag: 'group_flag_001', user_id: 111, group_id: 222, comment: '想加群' };
-      const request = Request.from(raw, {
-        $id: 'group_flag_001',
-        $adapter: 'icqq' as any,
-        $bot: 'bot2',
-        $type: 'group_add',
-        $subType: 'add',
-        $channel: { id: '222', type: 'group' },
-        $sender: { id: '111', name: '申请者' },
-        $comment: '想加群',
-        $timestamp: Date.now(),
-        $approve: async () => {},
-        $reject: async (reason?: string) => { rejected = true; },
-      });
-
-      expect(request.$type).toBe('group_add');
-      expect(request.group_id).toBe(222);
-      
-      await request.$reject('暂不接受');
-      expect(rejected).toBe(true);
-    });
-
-    it('群邀请', async () => {
-      let approved = false;
-      const raw = { flag: 'invite_001', user_id: 333, group_id: 444, group_name: '测试群' };
-      const request = Request.from(raw, {
-        $id: 'invite_001',
-        $adapter: 'onebot11' as any,
-        $bot: 'bot1',
-        $type: 'group_invite',
-        $subType: 'invite',
-        $channel: { id: '444', type: 'group' },
-        $sender: { id: '333', name: '邀请者' },
-        $timestamp: Date.now(),
-        $approve: async () => { approved = true; },
-        $reject: async () => {},
-      });
-
-      expect(request.$type).toBe('group_invite');
-      expect(request.group_name).toBe('测试群');
-
-      await request.$approve();
-      expect(approved).toBe(true);
-    });
-  });
-});