@f2a/network 0.1.2

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

@@ -0,0 +1,284 @@
+/**
+ * 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

@@ -0,0 +1,408 @@
+/**
+ * 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();
+    });
+  });
+});