@f2a/network 0.1.2 → 0.2.0

package/packages/openclaw-adapter/src/task-queue.edge-cases.test.ts

@@ -1,284 +0,0 @@
-/**
- * TaskQueue 边界、竞态和幂等性测试
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { TaskQueue } from './task-queue.js';
-import fs from 'fs';
-import path from 'path';
-
-const TEST_DIR = './test-tmp';
-
-describe('TaskQueue 边界问题', () => {
-  let queue: TaskQueue;
-
-  beforeEach(() => {
-    if (!fs.existsSync(TEST_DIR)) {
-      fs.mkdirSync(TEST_DIR, { recursive: true });
-    }
-    queue = new TaskQueue({
-      maxSize: 5,
-      maxAgeMs: 1000,
-      persistDir: TEST_DIR,
-      persistEnabled: true
-    });
-  });
-
-  afterEach(() => {
-    queue.close();
-    // 清理测试目录
-    if (fs.existsSync(TEST_DIR)) {
-      fs.rmSync(TEST_DIR, { recursive: true });
-    }
-  });
-
-  describe('队列边界', () => {
-    it('应该在队列满时抛出错误', () => {
-      // 添加 5 个任务（达到上限）
-      for (let i = 0; i < 5; i++) {
-        queue.add({ taskId: `task-${i}`, taskType: 'test' });
-      }
-
-      // 第 6 个应该失败
-      expect(() => queue.add({ taskId: 'task-6', taskType: 'test' }))
-        .toThrow('Task queue is full');
-    });
-
-    it('应该在队列空时返回空数组', () => {
-      expect(queue.getPending()).toEqual([]);
-      expect(queue.getStats().pending).toBe(0);
-    });
-
-    it('应该正确处理 null/undefined 参数', () => {
-      // @ts-expect-error 测试边界
-      expect(() => queue.add(null)).toThrow();
-      // @ts-expect-error 测试边界
-      expect(() => queue.add(undefined)).toThrow();
-    });
-  });
-
-  describe('任务过期清理', () => {
-    it('应该清理过期任务', async () => {
-      queue.add({ taskId: 'task-1', taskType: 'test' });
-      expect(queue.getStats().pending).toBe(1);
-
-      // 等待过期
-      await new Promise(r => setTimeout(r, 1100));
-
-      // 触发清理（通过添加新任务）
-      queue.add({ taskId: 'task-2', taskType: 'test' });
-      
-      // 旧任务应该被清理
-      expect(queue.get('task-1')).toBeUndefined();
-    });
-  });
-
-  describe('幂等性', () => {
-    it('应该覆盖相同 taskId 的任务', () => {
-      queue.add({ taskId: 'task-1', taskType: 'test', description: 'first' });
-      queue.add({ taskId: 'task-1', taskType: 'test', description: 'second' });
-
-      const task = queue.get('task-1');
-      expect(task?.description).toBe('second');
-      expect(queue.getStats().total).toBe(1); // 只有一个任务
-    });
-
-    it('应该正确处理重复的 markProcessing', () => {
-      queue.add({ taskId: 'task-1', taskType: 'test' });
-      
-      const first = queue.markProcessing('task-1');
-      const second = queue.markProcessing('task-1');
-
-      expect(first?.status).toBe('processing');
-      expect(second?.status).toBe('processing');
-      expect(queue.getStats().processing).toBe(1);
-    });
-
-    it('应该正确处理重复的 complete', () => {
-      queue.add({ taskId: 'task-1', taskType: 'test' });
-      
-      queue.complete('task-1', { status: 'success', result: 'first' });
-      queue.complete('task-1', { status: 'success', result: 'second' });
-
-      const task = queue.get('task-1');
-      expect(task?.result).toBe('second');
-    });
-  });
-
-  describe('SQLite 持久化', () => {
-    it('应该在关闭后保留任务', () => {
-      queue.add({ taskId: 'task-1', taskType: 'test' });
-      queue.add({ taskId: 'task-2', taskType: 'test' });
-      queue.markProcessing('task-1');
-
-      queue.close();
-
-      // 重新打开
-      const newQueue = new TaskQueue({
-        maxSize: 5,
-        persistDir: TEST_DIR,
-        persistEnabled: true
-      });
-
-      // 恢复后 processing 任务被重置为 pending，避免僵尸任务
-      const stats = newQueue.getStats();
-      expect(stats.pending).toBe(2); // task-1 和 task-2
-      expect(stats.processing).toBe(0);
-
-      newQueue.close();
-    });
-  });
-});
-
-describe('并发竞态条件', () => {
-  let queue: TaskQueue;
-
-  beforeEach(() => {
-    queue = new TaskQueue({ maxSize: 1000 });
-  });
-
-  afterEach(() => {
-    queue.close();
-  });
-
-  it('应该正确处理批量添加', () => {
-    // add() 是同步方法，不需要 Promise.resolve 包装
-    for (let i = 0; i < 100; i++) {
-      queue.add({ taskId: `task-${i}`, taskType: 'test' });
-    }
-
-    expect(queue.getStats().total).toBe(100);
-  });
-
-  it('应该正确处理批量 add 和 getPending', () => {
-    // 同步操作，不需要 Promise 包装
-    for (let i = 0; i < 50; i++) {
-      queue.add({ taskId: `task-${i}`, taskType: 'test' });
-      queue.getPending();
-    }
-
-    // 最终应该有 50 个任务
-    expect(queue.getStats().total).toBe(50);
-  });
-
-  it('应该正确处理批量 complete', () => {
-    for (let i = 0; i < 50; i++) {
-      queue.add({ taskId: `task-${i}`, taskType: 'test' });
-    }
-
-    // complete() 是同步方法，不需要 Promise 包装
-    for (let i = 0; i < 50; i++) {
-      queue.complete(`task-${i}`, { status: 'success' });
-    }
-
-    expect(queue.getStats().completed).toBe(50);
-  });
-
-  it('应该正确处理 taskId 输入验证', () => {
-    // 空字符串应该抛出错误
-    expect(() => queue.add({ taskId: '', taskType: 'test' })).toThrow('taskId must be a non-empty string');
-    
-    // 只有空格的字符串应该抛出错误
-    expect(() => queue.add({ taskId: '   ', taskType: 'test' })).toThrow('taskId must be a non-empty string');
-    
-    // 正常的 taskId 应该成功
-    expect(() => queue.add({ taskId: 'valid-task', taskType: 'test' })).not.toThrow();
-  });
-
-  it('应该保留重新添加任务的 createdAt 时间戳', () => {
-    queue.add({ taskId: 'task-1', taskType: 'test', description: 'first' });
-    const originalTask = queue.get('task-1');
-    const originalCreatedAt = originalTask?.createdAt;
-
-    // 等待一小段时间
-    const start = Date.now();
-    while (Date.now() - start < 10) { /* spin */ }
-
-    // 重新添加相同 taskId 的任务
-    queue.add({ taskId: 'task-1', taskType: 'test', description: 'second' });
-    const updatedTask = queue.get('task-1');
-
-    // createdAt 应该保持不变
-    expect(updatedTask?.createdAt).toBe(originalCreatedAt);
-    // 但 description 应该更新
-    expect(updatedTask?.description).toBe('second');
-  });
-});
-
-// P1 修复：测试僵尸任务重置功能
-describe('resetProcessingTask', () => {
-  let queue: TaskQueue;
-
-  beforeEach(() => {
-    if (!fs.existsSync(TEST_DIR)) {
-      fs.mkdirSync(TEST_DIR, { recursive: true });
-    }
-    queue = new TaskQueue({
-      maxSize: 5,
-      maxAgeMs: 1000,
-      persistDir: TEST_DIR,
-      persistEnabled: true
-    });
-  });
-
-  afterEach(() => {
-    queue.close();
-    if (fs.existsSync(TEST_DIR)) {
-      fs.rmSync(TEST_DIR, { recursive: true });
-    }
-  });
-
-  it('应该将 processing 任务重置为 pending', () => {
-    queue.add({ taskId: 'task-1', taskType: 'test', from: 'peer-1', timestamp: Date.now(), timeout: 30000 });
-    queue.markProcessing('task-1');
-    
-    expect(queue.get('task-1')?.status).toBe('processing');
-    
-    const result = queue.resetProcessingTask('task-1');
-    
-    expect(result?.status).toBe('pending');
-    expect(queue.get('task-1')?.status).toBe('pending');
-  });
-
-  it('应该只重置 processing 状态的任务', () => {
-    queue.add({ taskId: 'task-1', taskType: 'test', from: 'peer-1', timestamp: Date.now(), timeout: 30000 });
-    // 任务状态是 pending，不应该被重置
-    const result = queue.resetProcessingTask('task-1');
-    expect(result).toBeUndefined();
-    expect(queue.get('task-1')?.status).toBe('pending');
-  });
-
-  it('应该对不存在的任务返回 undefined', () => {
-    const result = queue.resetProcessingTask('non-existent');
-    expect(result).toBeUndefined();
-  });
-
-  it('应该更新 updatedAt 时间戳', () => {
-    queue.add({ taskId: 'task-1', taskType: 'test', from: 'peer-1', timestamp: Date.now(), timeout: 30000 });
-    queue.markProcessing('task-1');
-    
-    const beforeReset = Date.now();
-    const result = queue.resetProcessingTask('task-1');
-    const afterReset = Date.now();
-    
-    expect(result?.updatedAt).toBeGreaterThanOrEqual(beforeReset);
-    expect(result?.updatedAt).toBeLessThanOrEqual(afterReset);
-  });
-
-  it('应该在持久化后保持重置状态', () => {
-    queue.add({ taskId: 'task-1', taskType: 'test', from: 'peer-1', timestamp: Date.now(), timeout: 30000 });
-    queue.markProcessing('task-1');
-    queue.resetProcessingTask('task-1');
-    queue.close();
-
-    // 创建新队列，应该恢复任务且状态为 pending
-    const newQueue = new TaskQueue({
-      maxSize: 5,
-      maxAgeMs: 1000,
-      persistDir: TEST_DIR,
-      persistEnabled: true
-    });
-    expect(newQueue.get('task-1')?.status).toBe('pending');
-    newQueue.close();
-  });
-});

package/packages/openclaw-adapter/src/task-queue.persistence.test.ts

@@ -1,408 +0,0 @@
-/**
- * TaskQueue 崩溃恢复测试
- * 测试 SQLite 持久化和恢复
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { TaskQueue } from './task-queue.js';
-import fs from 'fs';
-import path from 'path';
-import Database from 'better-sqlite3';
-import { randomUUID } from 'crypto';
-
-describe('TaskQueue 崩溃恢复测试', () => {
-  let queue: TaskQueue;
-  let testDir: string;
-
-  beforeEach(() => {
-    // 为每个测试使用唯一的目录，确保测试隔离
-    testDir = `./test-tmp-persistence-${randomUUID()}`;
-    fs.mkdirSync(testDir, { recursive: true });
-    queue = new TaskQueue({
-      maxSize: 1000,
-      maxAgeMs: 60000,
-      persistDir: testDir,
-      persistEnabled: true
-    });
-  });
-
-  afterEach(() => {
-    try {
-      queue?.close();
-    } catch (e) {
-      // 忽略关闭错误
-    }
-    // 使用唯一目录，清理更可靠
-    if (testDir && fs.existsSync(testDir)) {
-      try {
-        fs.rmSync(testDir, { recursive: true, force: true });
-      } catch (e) {
-        // 忽略删除错误（可能文件被锁定）
-      }
-    }
-  });
-
-  describe('基本持久化和恢复', () => {
-    it('应该在关闭后保留 pending 任务', () => {
-      queue.add({ taskId: 'pending-task-1', taskType: 'test', description: 'Pending task' });
-      queue.add({ taskId: 'pending-task-2', taskType: 'test', description: 'Pending task 2' });
-      
-      queue.close();
-
-      // 重新打开
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      const stats = newQueue.getStats();
-      expect(stats.pending).toBe(2);
-
-      const task1 = newQueue.get('pending-task-1');
-      expect(task1?.description).toBe('Pending task');
-      expect(task1?.status).toBe('pending');
-
-      newQueue.close();
-    });
-
-    it('应该在关闭后保留 processing 任务（恢复为 pending）', () => {
-      queue.add({ taskId: 'processing-task', taskType: 'test' });
-      queue.markProcessing('processing-task');
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      // 恢复后 processing 任务被重置为 pending，避免僵尸任务
-      const stats = newQueue.getStats();
-      expect(stats.pending).toBe(1);
-      expect(stats.processing).toBe(0);
-
-      const task = newQueue.get('processing-task');
-      expect(task?.status).toBe('pending');
-
-      newQueue.close();
-    });
-
-    it('不应该恢复已完成任务', () => {
-      queue.add({ taskId: 'completed-task', taskType: 'test' });
-      queue.complete('completed-task', { status: 'success', result: 'done' });
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      const stats = newQueue.getStats();
-      expect(stats.completed).toBe(0); // 已完成任务不恢复到内存
-      expect(stats.total).toBe(0);
-
-      newQueue.close();
-    });
-
-    it('不应该恢复已失败任务', () => {
-      queue.add({ taskId: 'failed-task', taskType: 'test' });
-      queue.complete('failed-task', { status: 'error', error: 'Something went wrong' });
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      const stats = newQueue.getStats();
-      expect(stats.failed).toBe(0);
-      expect(stats.total).toBe(0);
-
-      newQueue.close();
-    });
-  });
-
-  describe('模拟崩溃场景', () => {
-    it('应该在未正常关闭后恢复数据', () => {
-      queue.add({ taskId: 'crash-task-1', taskType: 'test' });
-      queue.add({ taskId: 'crash-task-2', taskType: 'test' });
-      queue.markProcessing('crash-task-1');
-
-      // 模拟崩溃：不调用 close()
-      // 直接删除队列对象
-      // @ts-expect-error 模拟崩溃
-      queue = null;
-
-      // 强制 GC（如果可用）
-      if (global.gc) {
-        global.gc();
-      }
-
-      // 重新打开
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      // 恢复后 processing 任务被重置为 pending，避免僵尸任务
-      const stats = newQueue.getStats();
-      expect(stats.pending).toBe(2); // crash-task-1 和 crash-task-2
-      expect(stats.processing).toBe(0);
-
-      newQueue.close();
-    });
-
-    it('应该在部分写入后恢复一致状态', () => {
-      // 直接操作数据库模拟部分写入
-      const dbPath = path.join(testDir, 'task-queue.db');
-      
-      queue.add({ taskId: 'partial-1', taskType: 'test' });
-      
-      // 在事务中途关闭队列
-      const db = new Database(dbPath);
-      db.exec('BEGIN');
-      db.prepare('INSERT INTO tasks (id, task_type, status, created_at) VALUES (?, ?, ?, ?)')
-        .run('partial-2', 'test', 'pending', Date.now());
-      // 不提交事务，直接关闭
-      db.close();
-
-      // 重新打开队列
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      // partial-2 应该不在（事务未提交）
-      const task = newQueue.get('partial-2');
-      expect(task).toBeUndefined();
-
-      // partial-1 应该在
-      expect(newQueue.get('partial-1')).toBeDefined();
-
-      newQueue.close();
-    });
-
-    it('应该处理数据库文件损坏', () => {
-      queue.add({ taskId: 'before-corrupt', taskType: 'test' });
-      queue.close();
-
-      // 损坏数据库文件
-      const dbPath = path.join(testDir, 'task-queue.db');
-      fs.writeFileSync(dbPath, 'corrupted data here');
-
-      // 应该能够创建新数据库
-      expect(() => {
-        const newQueue = new TaskQueue({
-          maxSize: 1000,
-          persistDir: testDir,
-          persistEnabled: true
-        });
-        newQueue.close();
-      }).not.toThrow();
-    });
-  });
-
-  describe('数据库状态恢复', () => {
-    it('应该恢复任务的完整状态', () => {
-      const taskData = {
-        taskId: 'full-state-task',
-        taskType: 'full-test',
-        description: 'Full state test',
-        parameters: { key: 'value', nested: { data: 123 } }
-      };
-      
-      queue.add(taskData);
-      queue.markProcessing('full-state-task');
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      const task = newQueue.get('full-state-task');
-      expect(task?.taskType).toBe('full-test');
-      expect(task?.description).toBe('Full state test');
-      expect(task?.parameters).toEqual({ key: 'value', nested: { data: 123 } });
-      // 恢复后 processing 任务被重置为 pending，避免僵尸任务
-      expect(task?.status).toBe('pending');
-
-      newQueue.close();
-    });
-
-    it('应该恢复 webhook 推送状态', () => {
-      queue.add({ taskId: 'webhook-state-task', taskType: 'webhook' });
-      queue.markWebhookPushed('webhook-state-task');
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      const task = newQueue.get('webhook-state-task');
-      expect(task?.webhookPushed).toBe(true);
-
-      newQueue.close();
-    });
-
-    it('应该恢复时间戳', () => {
-      const beforeAdd = Date.now();
-      queue.add({ taskId: 'timestamp-task', taskType: 'timestamp' });
-      queue.markProcessing('timestamp-task');
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      const task = newQueue.get('timestamp-task');
-      expect(task?.createdAt).toBeGreaterThanOrEqual(beforeAdd);
-      expect(task?.updatedAt).toBeDefined();
-      expect(task?.updatedAt).toBeGreaterThanOrEqual(beforeAdd);
-
-      newQueue.close();
-    });
-  });
-
-  describe('多实例恢复', () => {
-    it('应该在多实例间共享数据', () => {
-      queue.add({ taskId: 'shared-task', taskType: 'shared' });
-      queue.close();
-
-      // 同时打开多个实例（注意：实际中应该避免这种情况）
-      const queue1 = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      const task = queue1.get('shared-task');
-      expect(task).toBeDefined();
-
-      queue1.close();
-    });
-  });
-
-  describe('数据库清理', () => {
-    it('应该在恢复时忽略已删除的任务', () => {
-      queue.add({ taskId: 'to-delete', taskType: 'delete' });
-      queue.add({ taskId: 'to-keep', taskType: 'keep' });
-      queue.delete('to-delete');
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      expect(newQueue.get('to-delete')).toBeUndefined();
-      expect(newQueue.get('to-keep')).toBeDefined();
-
-      newQueue.close();
-    });
-
-    it('应该正确处理大量恢复任务', () => {
-      // 添加大量任务
-      for (let i = 0; i < 100; i++) {
-        queue.add({ taskId: `bulk-task-${i}`, taskType: 'bulk' });
-      }
-      
-      // 标记一些为 processing
-      for (let i = 0; i < 10; i++) {
-        queue.markProcessing(`bulk-task-${i}`);
-      }
-      
-      queue.close();
-
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      // 恢复后 processing 任务被重置为 pending，避免僵尸任务
-      const stats = newQueue.getStats();
-      expect(stats.pending).toBe(100);
-      expect(stats.processing).toBe(0);
-      expect(stats.total).toBe(100);
-
-      newQueue.close();
-    });
-  });
-
-  describe('错误恢复', () => {
-    it('应该处理无效的 JSON 数据', () => {
-      const dbPath = path.join(testDir, 'task-queue.db');
-      
-      queue.add({ taskId: 'valid-task', taskType: 'test' });
-      queue.close();
-
-      // 插入无效 JSON
-      const db = new Database(dbPath);
-      db.prepare('INSERT INTO tasks (id, task_type, status, created_at, parameters) VALUES (?, ?, ?, ?, ?)')
-        .run('invalid-json-task', 'test', 'pending', Date.now(), '{ invalid json }');
-      db.close();
-
-      // 应该能够启动并跳过无效数据
-      const newQueue = new TaskQueue({
-        maxSize: 1000,
-        persistDir: testDir,
-        persistEnabled: true
-      });
-
-      // 有效任务应该存在
-      expect(newQueue.get('valid-task')).toBeDefined();
-
-      newQueue.close();
-    });
-
-    it('应该处理缺失的列', () => {
-      const dbPath = path.join(testDir, 'task-queue.db');
-      
-      queue.close();
-
-      // 创建一个不同 schema 的表
-      const db = new Database(dbPath);
-      db.exec('DROP TABLE IF EXISTS tasks');
-      db.exec(`
-        CREATE TABLE tasks (
-          id TEXT PRIMARY KEY,
-          status TEXT NOT NULL,
-          created_at INTEGER NOT NULL
-          -- 缺少其他列
-        )
-      `);
-      db.prepare('INSERT INTO tasks (id, status, created_at) VALUES (?, ?, ?)')
-        .run('minimal-task', 'pending', Date.now());
-      db.close();
-
-      // 应该能够处理缺失的列
-      expect(() => {
-        const newQueue = new TaskQueue({
-          maxSize: 1000,
-          persistDir: testDir,
-          persistEnabled: true
-        });
-        newQueue.close();
-      }).not.toThrow();
-    });
-  });
-});