@ai-setting/roy-agent-core 1.0.0

package/src/env/task/storage/sqlite-task-store.test.ts

@@ -0,0 +1,283 @@
+/**
+ * @fileoverview SQLite Task Store Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { SQLiteTaskStore, TaskStore } from "./sqlite-task-store";
+import { tmpdir } from "os";
+import { join } from "path";
+
+describe("SQLiteTaskStore", () => {
+  let store: TaskStore;
+  
+  beforeEach(async () => {
+    // 每个测试使用唯一的数据库路径，确保隔离
+    const testDbPath = join(tmpdir(), `task-store-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+    store = new SQLiteTaskStore(testDbPath);
+  });
+  
+  afterEach(async () => {
+    await store.close();
+  });
+  
+  describe("createTask", () => {
+    it("should create a task with required fields", async () => {
+      const task = await store.createTask({
+        title: "Test Task",
+        sessionId: "sess_123",
+      });
+      
+      expect(task.id).toBeGreaterThan(0);
+      expect(task.title).toBe("Test Task");
+      expect(task.status).toBe("todo");
+      expect(task.priority).toBe("medium");
+    });
+    
+    it("should create task with all options", async () => {
+      const task = await store.createTask({
+        title: "Full Task",
+        description: "Description",
+        priority: "high",
+        sessionId: "sess_123",
+        tags: ["feature", "urgent"],
+      });
+      
+      expect(task.description).toBe("Description");
+      expect(task.priority).toBe("high");
+      expect(task.tags).toEqual(["feature", "urgent"]);
+    });
+  });
+  
+  describe("CRUD operations", () => {
+    it("should perform full CRUD cycle", async () => {
+      // Create
+      const created = await store.createTask({ title: "CRUD Test", sessionId: "sess_123" });
+      expect(created.id).toBeGreaterThan(0);
+      
+      // Read
+      const read = await store.getTask(created.id);
+      expect(read?.title).toBe("CRUD Test");
+      
+      // Update
+      const updated = await store.updateTask(created.id, { status: "active", progress: 50 });
+      expect(updated?.status).toBe("active");
+      expect(updated?.progress).toBe(50);
+      
+      // Delete
+      const deleted = await store.deleteTask(created.id);
+      expect(deleted).toBe(true);
+      const notFound = await store.getTask(created.id);
+      expect(notFound).toBeUndefined();
+    });
+    
+    it("should update current_status field", async () => {
+      const task = await store.createTask({ title: "Test", sessionId: "sess_123" });
+      
+      const updated = await store.updateTask(task.id, { 
+        current_status: "正在实现登录功能" 
+      });
+      
+      expect(updated?.current_status).toBe("正在实现登录功能");
+    });
+  });
+  
+  describe("operations", () => {
+    it("should create and list operations", async () => {
+      const task = await store.createTask({ title: "Task", sessionId: "sess_123" });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_123",
+        actionType: "create",
+        actionTitle: "Task created",
+      });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_456",  // different session!
+        actionType: "progress",
+        actionTitle: "Made progress",
+      });
+      
+      const ops = await store.listOperations({ taskId: task.id });
+      expect(ops.length).toBe(2);
+    });
+    
+    it("should track sessionId for each operation", async () => {
+      const task = await store.createTask({ title: "Task", sessionId: "sess_1" });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_1",
+        actionType: "create",
+        actionTitle: "Started in session 1",
+      });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_2",
+        actionType: "progress",
+        actionTitle: "Continued in session 2",
+      });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_3",
+        actionType: "milestone",
+        actionTitle: "Reached milestone in session 3",
+      });
+      
+      const ops = await store.listOperations({ taskId: task.id });
+      const sessions = new Set(ops.map(op => op.sessionId));
+      expect(sessions.has("sess_1")).toBe(true);
+      expect(sessions.has("sess_2")).toBe(true);
+      expect(sessions.has("sess_3")).toBe(true);
+    });
+    
+    it("should filter operations by action type", async () => {
+      const task = await store.createTask({ title: "Task", sessionId: "sess_1" });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_1",
+        actionType: "create",
+        actionTitle: "Created",
+      });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_2",
+        actionType: "progress",
+        actionTitle: "Progress 1",
+      });
+      
+      await store.createOperation({
+        taskId: task.id,
+        sessionId: "sess_3",
+        actionType: "progress",
+        actionTitle: "Progress 2",
+      });
+      
+      const progressOps = await store.listOperations({ 
+        taskId: task.id, 
+        actionType: "progress" 
+      });
+      
+      expect(progressOps.length).toBe(2);
+      expect(progressOps.every(op => op.actionType === "progress")).toBe(true);
+    });
+    
+    it("should support pagination", async () => {
+      const task = await store.createTask({ title: "Task", sessionId: "sess_1" });
+      
+      // Create 5 operations
+      for (let i = 0; i < 5; i++) {
+        await store.createOperation({
+          taskId: task.id,
+          sessionId: `sess_${i}`,
+          actionType: "progress",
+          actionTitle: `Progress ${i}`,
+        });
+      }
+      
+      // Get first 2
+      const firstPage = await store.listOperations({ 
+        taskId: task.id, 
+        limit: 2, 
+        offset: 0 
+      });
+      expect(firstPage.length).toBe(2);
+      
+      // Get next 2
+      const secondPage = await store.listOperations({ 
+        taskId: task.id, 
+        limit: 2, 
+        offset: 2 
+      });
+      expect(secondPage.length).toBe(2);
+    });
+  });
+  
+  describe("listTasks", () => {
+    it("should list tasks with default order", async () => {
+      await store.createTask({ title: "Task 1", sessionId: "sess_1" });
+      await store.createTask({ title: "Task 2", sessionId: "sess_1" });
+      
+      const tasks = await store.listTasks();
+      expect(tasks.length).toBe(2);
+    });
+    
+    it("should filter by status", async () => {
+      const task1 = await store.createTask({ title: "Active Task", sessionId: "sess_1" });
+      const task2 = await store.createTask({ title: "Todo Task", sessionId: "sess_1" });
+      
+      await store.updateTask(task1.id, { status: "active" });
+      
+      const activeTasks = await store.listTasks({ status: "active" });
+      expect(activeTasks.length).toBe(1);
+      expect(activeTasks[0].title).toBe("Active Task");
+    });
+    
+    it("should filter by priority", async () => {
+      const task1 = await store.createTask({ title: "High Task", sessionId: "sess_1", priority: "high" });
+      const task2 = await store.createTask({ title: "Low Task", sessionId: "sess_1", priority: "low" });
+      
+      const highTasks = await store.listTasks({ priority: "high" });
+      expect(highTasks.length).toBe(1);
+      expect(highTasks[0].title).toBe("High Task");
+    });
+  });
+  
+  describe("searchTasksByKeywords", () => {
+    it("should limit results to specified limit", async () => {
+      // Create 10 tasks with same tag
+      for (let i = 0; i < 10; i++) {
+        await store.createTask({ 
+          title: `Task ${i}`, 
+          sessionId: "sess_1",
+          tags: ["test-tag"],
+        });
+      }
+      
+      // Search with limit=5
+      const results = await store.searchTasksByKeywords(["test-tag"], { limit: 5 });
+      expect(results.length).toBe(5);
+    });
+    
+    it("should limit findSimilarTasksByKeywords to 5 by default", async () => {
+      // Create 10 tasks with same tag
+      for (let i = 0; i < 10; i++) {
+        await store.createTask({ 
+          title: `Similar Task ${i}`, 
+          sessionId: "sess_1",
+          tags: ["feature"],
+        });
+      }
+      
+      // Search without explicit limit - should use default 5
+      const results = await store.findSimilarTasksByKeywords(["feature"]);
+      expect(results.length).toBe(5);
+    });
+    
+    it("should exclude specified taskId", async () => {
+      const targetTask = await store.createTask({ 
+        title: "Target Task", 
+        sessionId: "sess_1",
+        tags: ["bug"],
+      });
+      
+      // Create some similar tasks
+      await store.createTask({ title: "Bug 1", sessionId: "sess_1", tags: ["bug"] });
+      await store.createTask({ title: "Bug 2", sessionId: "sess_1", tags: ["bug"] });
+      
+      // Search excluding target task
+      const results = await store.searchTasksByKeywords(["bug"], { 
+        limit: 10, 
+        excludeTaskId: targetTask.id 
+      });
+      
+      // Should not contain target task
+      expect(results.some(t => t.id === targetTask.id)).toBe(false);
+    });
+  });
+});