test: add auto-capture lock contention test (Issue #665)

Author: jlin53882

test/auto-capture-lock-contention.test.mjs

@@ -0,0 +1,179 @@
+// test/auto-capture-lock-contention.test.mjs
+/**
+ * Auto-Capture Lock Contention Test
+ * 
+ * 測試目標：
+ * 模擬 auto-capture 產生多個記憶時，每次寫入都會取得 lock
+ * 對比：單獨寫入 vs 批次寫入的 lock 次數
+ * 
+ * 這個測試用於驗證 Issue #665 的問題存在
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import jitiFactory from "jiti";
+
+const jiti = jitiFactory(import.meta.url, { interopDefault: true });
+
+describe("Auto-Capture Lock Contention", () => {
+  // 追蹤 lock 取得次數
+  let lockAcquisitionCount = 0;
+  
+  // 測試 1：模擬 auto-capture 單獨寫入（N 次 lock）
+  it("should acquire lock N times for N entries (current behavior)", async () => {
+    const { MemoryStore } = jiti("../src/store.ts");
+    const dir = mkdtempSync(join(tmpdir(), "memory-acquire-lock-"));
+    
+    const store = new MemoryStore({
+      dbPath: dir,
+      vectorDim: 128,
+    });
+    
+    // 模擬 auto-capture 產生 10 個記憶
+    const entries = Array(10).fill(null).map((_, i) => ({
+      text: `Auto-capture memory ${i}`,
+      vector: new Array(128).fill(Math.random()),
+      category: "fact",
+      scope: "test",
+      importance: 0.5,
+      metadata: "{}",
+    }));
+    
+    // 測量：每次單獨寫入
+    const start = Date.now();
+    for (const entry of entries) {
+      await store.store(entry);
+    }
+    const duration = Date.now() - start;
+    
+    console.log(`[Individual] 10 entries: ${duration}ms`);
+    
+    await store.destroy();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  // 測試 2：模擬高並發 auto-capture（實際壓測）
+  it("should demonstrate lock contention with 20 concurrent auto-captures", async () => {
+    const { MemoryStore } = jiti("../src/store.ts");
+    const dir = mkdtempSync(join(tmpdir(), "memory-ac-concurrent-"));
+    
+    const store = new MemoryStore({
+      dbPath: dir,
+      vectorDim: 64,
+    });
+    
+    // 模擬 20 個並發的 auto-capture 操作
+    // 每個操作都會取得 lock
+    const results = await Promise.allSettled(
+      Array(20).fill(null).map((_, i) => 
+        store.store({
+          text: `Concurrent auto-capture ${i}`,
+          vector: new Array(64).fill(0.1),
+          category: "fact",
+          scope: "agent:test",
+          importance: 0.5,
+          metadata: "{}",
+        })
+      )
+    );
+    
+    const successCount = results.filter(r => r.status === "fulfilled").length;
+    const failCount = results.filter(r => r.status === "rejected").length;
+    
+    console.log(`[Concurrent] 20 auto-captures: ${successCount} success, ${failCount} failed`);
+    
+    // 使用 Redis lock 後，成功率應該很高
+    // 但在 Redis 不可用時會 fallback 到 file lock
+    assert.ok(successCount >= 15, `Expected at least 15 successful, got ${successCount}`);
+    
+    await store.destroy();
+    rmSync(dir, { recursive: true, force: true });
+  }, 60000);
+
+  // 測試 3：批次寫入的理論模擬（展示改善方向）
+  it("batch write would reduce lock acquisitions", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "memory-batch-sim-"));
+    const { MemoryStore } = jiti("../src/store.ts");
+    const store = new MemoryStore({
+      dbPath: dir,
+      vectorDim: 32,
+    });
+    
+    // 理論計算：
+    // - 單獨寫入：10 entries = 10 次 lock
+    // - 批次寫入：10 entries = 1 次 lock
+    // 
+    // 這個測試只是展示概念，實際批次寫入需要實作 bulkStore
+    
+    const entries = Array(10).fill(null).map((_, i) => ({
+      text: `Batch memory ${i}`,
+      vector: new Array(32).fill(0.1),
+      category: "fact",
+      scope: "test",
+      importance: 0.5,
+      metadata: "{}",
+    }));
+    
+    // 單獨寫入（現有行為）
+    const individualStart = Date.now();
+    for (const entry of entries) {
+      await store.store(entry);
+    }
+    const individualTime = Date.now() - individualStart;
+    
+    console.log(`[Theoretical] Individual: 10 lock acquisitions in ${individualTime}ms`);
+    console.log(`[Theoretical] Batch (not implemented): would be ~1 lock acquisition`);
+    console.log(`[Theoretical] Improvement: ~${((individualTime - 100) / individualTime * 100).toFixed(0)}% faster`);
+    
+    await store.destroy();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  // 測試 4：真實的 lock 開銷測量
+  it("measure actual lock overhead", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "memory-lock-overhead-"));
+    const { MemoryStore } = jiti("../src/store.ts");
+    const store = new MemoryStore({
+      dbPath: dir,
+      vectorDim: 16,
+    });
+    
+    // 測量 50 次寫入的總時間
+    const times = [];
+    for (let i = 0; i < 50; i++) {
+      const start = Date.now();
+      await store.store({
+        text: `Measure ${i}`,
+        vector: new Array(16).fill(0.1),
+        category: "fact",
+        scope: "test",
+        importance: 0.5,
+        metadata: "{}",
+      });
+      times.push(Date.now() - start);
+    }
+    
+    const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
+    const maxTime = Math.max(...times);
+    const minTime = Math.min(...times);
+    
+    console.log(`[Lock Overhead] 50 writes:`);
+    console.log(`  - Average: ${avgTime.toFixed(2)}ms`);
+    console.log(`  - Min: ${minTime}ms`);
+    console.log(`  - Max: ${maxTime}ms`);
+    
+    // 如果 maxTime 很高，表示有 lock 競爭
+    if (maxTime > 5000) {
+      console.log(`⚠️  High max time (${maxTime}ms) indicates lock contention!`);
+    }
+    
+    await store.destroy();
+    rmSync(dir, { recursive: true, force: true });
+  }, 120000);
+});
+
+console.log("=== Auto-Capture Lock Contention Tests ===");
+console.log("This test demonstrates Issue #665: auto-capture creates multiple lock acquisitions");