memories-lite 0.9.1 → 0.9.3

package/tests/memory.users.test.ts

@@ -0,0 +1,235 @@
+/// <reference types="jest" />
+import { MemoriesLite } from "../src";
+import { SearchResult } from "../src/types";
+import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
+
+dotenv.config();
+
+jest.setTimeout(30000); // Increase timeout to 30 seconds
+
+describe("MemoriesLite - User Separation Tests", () => {
+  let memory: MemoriesLite;
+  let userAlice: string;
+  let userBob: string;
+  
+
+  beforeEach(async () => {
+    // Initialize a single memory instance that will be shared by both users
+    ({ memory } = createTestMemory({rootPath: process.cwd(), secure: true}));
+    
+    // Create a second userId
+    userAlice = `alice-1`;
+    userBob = `bob-2`;
+    
+    // Reset all memories before each test
+    await memory.reset(userAlice);
+    await memory.reset(userBob);
+  });
+
+  afterEach(async () => {
+    // Clean up after each test
+    await memory.reset(userAlice);
+    await memory.reset(userBob);
+  });
+
+  describe("Basic User Separation", () => {
+    it("should keep memories separate between users", async () => {
+      // Add a memory for user 1
+      const memory1 = "My name is Alice and I love hiking";
+      const result1 = (await memory.capture(memory1, userAlice, {})) as SearchResult;
+      expect(result1.results.length).toBeGreaterThanOrEqual(1);
+
+      // Get all memories for user 1
+      const allbob = (await memory.getAll(userBob, {})) as SearchResult;
+      expect(allbob.results.length).toBe(0);
+      
+      // Add a different memory for user 2
+      const memory2 = "My name is Bob and I enjoy swimming";
+      const result2 = (await memory.capture(memory2, userBob, {})) as SearchResult;
+      expect(result2.results.length).toBeGreaterThanOrEqual(1);
+      
+      // Get all memories for user 1
+      const allMemories1 = (await memory.getAll(userAlice, {})) as SearchResult;
+      expect(allMemories1.results.length).toBeGreaterThanOrEqual(1);;
+      
+      // Get all memories for user 2
+      const allMemories2 = (await memory.getAll(userBob, {})) as SearchResult;
+      expect(allMemories2.results.length).toBeGreaterThanOrEqual(1);
+      
+      // Verify user 1 can only see their own memories
+      const containsAlice = allMemories1.results.some(item => 
+        item.memory.includes("Alice") || item.memory.includes("hiking"));
+      const containsBob = allMemories1.results.some(item => 
+        item.memory.includes("Bob") || item.memory.includes("swimming"));
+      
+      expect(containsAlice).toBe(true);
+      expect(containsBob).toBe(false);
+      
+      // Verify user 2 can only see their own memories
+      const user2ContainsAlice = allMemories2.results.some(item => 
+        item.memory.includes("Alice") || item.memory.includes("hiking"));
+      const user2ContainsBob = allMemories2.results.some(item => 
+        item.memory.includes("Bob") || item.memory.includes("swimming"));
+      
+      expect(user2ContainsAlice).toBe(false);
+      expect(user2ContainsBob).toBe(true);
+    });
+
+    it("should not allow cross-user memory access", async () => {
+      // Add a memory for user 1
+      const result1 = (await memory.capture(
+        "I prefer to be called Alex instead of Alexander",
+        userAlice,
+        {},
+      )) as SearchResult;
+      
+      expect(result1.results.length).toBe(1);
+      const memoryId = result1.results[0].id;
+      
+      // User 1 can access their memory
+      const memoryForUser1 = await memory.get(memoryId, userAlice);
+      expect(memoryForUser1).not.toBeNull();
+      
+      // User 2 cannot access user 1's memory
+      const memoryForUser2 = await memory.get(memoryId, userBob);
+      expect(memoryForUser2).toBeNull();
+
+      const allMemories2 = (await memory.getAll(userBob, {})) as SearchResult;
+      expect(allMemories2.results.length).toBe(0);
+
+    });
+  });
+
+  describe("Memory Operations Across Users", () => {
+    it("should keep retrieve results separate between users", async () => {
+      // Add similar memories for both users
+      await memory.capture("I live in Paris and love French cuisine", userAlice, {});
+      await memory.capture("I live in Lyon and enjoy French wine", userBob, {});
+      
+      // Search for "France" for both users
+      const results1 = (await memory.retrieve("Where do you live?", userAlice, {})) as SearchResult;
+      const results2 = (await memory.retrieve("France et Lyon", userBob, {})) as SearchResult;
+      
+      // Verify that user 1 only sees their Paris memory
+      const containsParis = results1.results.some(item => item.memory.includes("Paris"));
+      const containsLyon = results1.results.some(item => item.memory.includes("Lyon"));
+      
+      expect(containsParis).toBe(true);
+      expect(containsLyon).toBe(false);
+      
+      // Verify that user 2 only sees their Lyon memory
+      const user2ContainsParis = results2.results.some(item => item.memory.includes("Paris"));
+      const user2ContainsLyon = results2.results.some(item => item.memory.includes("Lyon"));
+      
+      expect(user2ContainsParis).toBe(false);
+      expect(user2ContainsLyon).toBe(true);
+    });
+
+    it("should maintain user separation during updates", async () => {
+      // Add identical memories for both users
+      const result1 = (await memory.capture("My favorite color is blue", userAlice, {})) as SearchResult;
+      const result2 = (await memory.capture("My favorite color is blue", userBob, {})) as SearchResult;
+      
+      const memoryId1 = result1.results[0].id;
+      const memoryId2 = result2.results[0].id;
+      
+      // Update user 1's memory
+      await memory.update(memoryId1, "My favorite color is green", userAlice);
+      
+      // Verify user 1's memory was updated
+      const updatedMemory1 = await memory.get(memoryId1, userAlice);
+      expect(updatedMemory1?.memory).toBe("My favorite color is green");
+      
+      // Verify user 2's memory was NOT updated
+      const memory2 = await memory.get(memoryId2, userBob);
+      expect(memory2?.memory).toContain("blue");
+    });
+
+    it("should maintain user separation during deletes", async () => {
+      // Add identical memories for both users
+      const result1 = (await memory.capture("I enjoy playing tennis", userAlice, {})) as SearchResult;
+      const result2 = (await memory.capture("I enjoy playing tennis", userBob, {})) as SearchResult;
+      
+      const memoryId1 = result1.results[0].id;
+      const memoryId2 = result2.results[0].id;
+      
+      // Delete user 1's memory
+      await memory.delete(memoryId1, userAlice);
+      
+      // Verify user 1's memory was deleted
+      const memory1 = await memory.get(memoryId1, userAlice);
+      expect(memory1).toBeNull();
+      
+      // Verify user 2's memory still exists
+      const memory2 = await memory.get(memoryId2, userBob);
+      expect(memory2).not.toBeNull();
+      expect(memory2?.memory).toBe("I enjoy playing tennis");
+    });
+    
+    it("should reset only the targeted user's memories", async () => {
+      // Add memories for both users
+      await memory.capture("I'm learning to play piano", userAlice, {});
+      await memory.capture("I'm taking guitar lessons", userBob, {});
+      
+      // Reset only user1's memories
+      await memory.reset(userAlice);
+      
+      // Verify user1 has no memories
+      const memories1 = await memory.getAll(userAlice, {});
+      expect(memories1.results.length).toBe(0);
+      
+      // Verify user2 still has memories
+      const memories2 = await memory.getAll(userBob, {});
+      expect(memories2.results.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Memory Type Preservation Across Users", () => {
+    it("should preserve memory types distinctly for each user", async () => {
+      // Add memories with specific types for different users
+      const message1 = [
+        {role: "user", content: "Je préfère que tu me tutoies"},
+        {role: "assistant", content: "D'accord, je te tutoierai à partir de maintenant."}
+      ];
+      
+      const message2 = [
+        {role: "user", content: "Je préfère que vous me vouvoyiez"},
+        {role: "assistant", content: "D'accord, je vous vouvoierai à partir de maintenant."}
+      ];
+      
+      // Capture for user 1 (tutoring preference)
+      const result1 = (await memory.capture(message1, userAlice, {})) as SearchResult;
+      expect(result1.results.length).toBeGreaterThan(0);
+      expect(result1.results[0]?.type).toBe("assistant_preference");
+      
+      // Capture for user 2 (formal preference)
+      const result2 = (await memory.capture(message2, userBob, {})) as SearchResult;
+      expect(result2.results.length).toBeGreaterThan(0);
+      expect(result2.results[0]?.type).toBe("assistant_preference");
+      
+      // Retrieve preferences for both users
+      const retrieve1 = await memory.retrieve("How should I address the user?", userAlice, {});
+      const retrieve2 = await memory.retrieve("How should I address the user?", userBob, {});
+      
+      // Verify the correct preferences are returned for each user
+      const user1HasTutoring = retrieve1.results.some(item => 
+        item.memory.toLowerCase().includes("tutoie") || 
+        item.memory.toLowerCase().includes("tutoierai"));
+      
+      const user2HasFormal = retrieve2.results.some(item => 
+        item.memory.toLowerCase().includes("vouvoyiez") || 
+        item.memory.toLowerCase().includes("vouvoierai"));
+      
+      expect(user1HasTutoring).toBe(true);
+      expect(user2HasFormal).toBe(true);
+      
+      // Cross-check: User 1 should not have user 2's preference
+      const user1HasFormal = retrieve1.results.some(item => 
+        item.memory.toLowerCase().includes("vouvoyiez") || 
+        item.memory.toLowerCase().includes("vouvoierai"));
+      
+      expect(user1HasFormal).toBe(false);
+    });
+  });
+});