@ai.ntellect/core 0.6.16 → 0.6.19

package/test/{memory → modules/memory}/adapters/meilisearch.test.ts

@@ -1,117 +1,72 @@
-import { BaseMemoryService } from "@/interfaces";
-import { MeilisearchAdapter } from "@/memory/adapters/meilisearch";
-import { BaseMemoryType } from "@/types";
 import { expect } from "chai";
 import dotenv from "dotenv";
+import { MeilisearchAdapter } from "../../../memory/adapters/meilisearch";
+import { BaseMemoryType } from "../../../types";
 
 // Load environment variables
 dotenv.config();
 
 describe("MeilisearchAdapter", () => {
   let meilisearchAdapter: MeilisearchAdapter;
-  let mockBaseMemoryService: BaseMemoryService;
   const TEST_ROOM_ID = "test-room";
 
   const testMemory: BaseMemoryType = {
     id: "test-id",
     data: "test data",
-    query: "test query",
-    embedding: [0.1, 0.2, 0.3],
     roomId: "test-room",
     createdAt: new Date(),
   };
 
-  beforeEach(() => {
-    // Use real Meilisearch if environment variables are set, otherwise mock
-    if (process.env.MEILISEARCH_HOST && process.env.MEILISEARCH_API_KEY) {
-      // Real Meilisearch configuration
-      // console.log("Real Meilisearch configuration");
-      meilisearchAdapter = new MeilisearchAdapter(
-        {
-          host: process.env.MEILISEARCH_HOST,
-          apiKey: process.env.MEILISEARCH_API_KEY,
-          searchableAttributes: ["content"],
-          sortableAttributes: ["createdAt"],
-        },
-        mockBaseMemoryService
-      );
-    } else {
-      // Mock fetch implementation
-      // console.log("Mock Meilisearch configuration");
-      global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-        const url = input.toString();
+  beforeEach(async function () {
+    this.timeout(10000); // Augmenter le timeout
 
-        // Mock for index check/creation
-        if (url.includes("/indexes")) {
-          if (init?.method === "POST") {
-            return new Response(JSON.stringify({ taskUid: 1 }));
-          }
-          if (url.endsWith("/indexes")) {
-            return new Response(JSON.stringify({ results: [] }));
-          }
-          // Mock for specific index check
-          if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
-            return new Response(
-              JSON.stringify({
-                uid: TEST_ROOM_ID,
-                primaryKey: "id",
-              })
-            );
-          }
-          if (url.includes("/indexes/memories")) {
-            return new Response(
-              JSON.stringify({
-                uid: "memories",
-                primaryKey: "id",
-              })
-            );
-          }
-        }
+    // Mock fetch pour simuler l'existence de l'index
+    global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = input.toString();
 
-        // Mock for settings
-        if (url.includes("/settings")) {
-          return new Response(JSON.stringify({ acknowledged: true }));
+      // Mock pour index check/creation
+      if (url.includes("/indexes")) {
+        if (init?.method === "POST") {
+          return new Response(JSON.stringify({ taskUid: 1 }));
         }
-
-        // Mock for documents
-        if (url.includes("/documents")) {
-          if (init?.method === "POST") {
-            return new Response(JSON.stringify({ taskUid: 2 }));
-          }
-          if (init?.method === "DELETE") {
-            return new Response(JSON.stringify({ taskUid: 3 }));
-          }
-          return new Response(JSON.stringify([testMemory]));
+        if (url.endsWith("/indexes")) {
+          return new Response(
+            JSON.stringify({
+              results: [{ uid: TEST_ROOM_ID }], // Simuler l'existence de l'index
+            })
+          );
+        }
+        if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
+          return new Response(
+            JSON.stringify({
+              uid: TEST_ROOM_ID,
+              primaryKey: "id",
+            })
+          );
         }
+      }
 
-        return new Response(JSON.stringify({}));
-      };
+      // Mock pour settings et autres endpoints
+      if (url.includes("/settings")) {
+        return new Response(JSON.stringify({ acknowledged: true }));
+      }
 
-      mockBaseMemoryService = {
-        initializeConnection: async () => {},
-        createMemory: async () => {},
-        getMemoryById: async () => testMemory,
-        getMemoryByIndex: async () => [testMemory],
-        getAllMemories: async () => [testMemory],
-        clearMemoryById: async () => {},
-        clearAllMemories: async () => {},
-      };
+      return new Response(JSON.stringify({}));
+    };
 
-      meilisearchAdapter = new MeilisearchAdapter(
-        {
-          host: "http://localhost:7700",
-          apiKey: "aSampleMasterKey",
-          searchableAttributes: ["content"],
-          sortableAttributes: ["createdAt"],
-        },
-        mockBaseMemoryService
-      );
-    }
+    meilisearchAdapter = new MeilisearchAdapter({
+      host: "http://localhost:7700",
+      apiKey: "test_key",
+      searchableAttributes: ["content"],
+      sortableAttributes: ["createdAt"],
+    });
+
+    await meilisearchAdapter.init(TEST_ROOM_ID);
   });
 
   describe("Initialization", () => {
     it("should initialize storage", async () => {
-      await expect(meilisearchAdapter.init()).to.not.throw;
+      await expect(meilisearchAdapter.init("test-room")).to.not.throw;
     });
   });
 
@@ -170,7 +125,7 @@ describe("MeilisearchAdapter", () => {
       }
 
       try {
-        await meilisearchAdapter.init();
+        await meilisearchAdapter.init(TEST_ROOM_ID);
         await meilisearchAdapter.initializeStorage(TEST_ROOM_ID);
       } catch (error) {
         console.error("Failed to initialize:", error);
@@ -181,7 +136,6 @@ describe("MeilisearchAdapter", () => {
     it("should create memory", async () => {
       const result = await meilisearchAdapter.createMemory({
         data: "test data",
-        query: "test query",
         roomId: TEST_ROOM_ID,
       });
 
@@ -243,28 +197,60 @@ describe("MeilisearchAdapter", () => {
     });
 
     it("should clear all memories", async () => {
+      // S'assurer que l'index existe avant de le supprimer
+      await meilisearchAdapter.init(TEST_ROOM_ID);
       await expect(meilisearchAdapter.clearAllMemories()).to.not.throw;
     });
 
     it("should not create duplicate memory with same data", async () => {
-      // Create first memory
+      // Override fetch mock for this test
+      const firstMemoryId = "test-memory-id";
+      const mockMemory = {
+        id: firstMemoryId,
+        data: "test data",
+        roomId: TEST_ROOM_ID,
+        embedding: null,
+        createdAt: new Date().toISOString(),
+      };
+
+      global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = input.toString();
+
+        if (url.includes("/search")) {
+          return new Response(
+            JSON.stringify({
+              hits: [{ ...mockMemory }],
+            })
+          );
+        }
+
+        if (url.includes("/indexes")) {
+          if (init?.method === "POST") {
+            return new Response(JSON.stringify({ taskUid: 1 }));
+          }
+          return new Response(
+            JSON.stringify({
+              uid: TEST_ROOM_ID,
+              primaryKey: "id",
+            })
+          );
+        }
+
+        return new Response(JSON.stringify({}));
+      };
+
       const firstMemory = await meilisearchAdapter.createMemory({
         data: "test data",
-        query: "test query",
         roomId: TEST_ROOM_ID,
       });
 
-      // Try to create second memory with same data
       const secondMemory = await meilisearchAdapter.createMemory({
         data: "test data",
-        query: "test query",
         roomId: TEST_ROOM_ID,
       });
 
-      expect(secondMemory).to.exist;
       expect(secondMemory?.id).to.equal(firstMemory?.id);
       expect(secondMemory?.data).to.equal(firstMemory?.data);
-      expect(secondMemory?.query).to.equal(firstMemory?.query);
       expect(secondMemory?.roomId).to.equal(firstMemory?.roomId);
     });
 

package/test/modules/memory/adapters/redis.test.ts

@@ -0,0 +1,169 @@
+import { expect } from "chai";
+import dotenv from "dotenv";
+import Redis from "ioredis";
+import { IMemoryAdapter } from "../../../interfaces";
+import { RedisAdapter } from "../../../memory/adapters/redis";
+import { BaseMemoryType } from "../../../types";
+
+// Load environment variables
+dotenv.config();
+
+describe("RedisAdapter", () => {
+  before(function () {
+    this.timeout(30000);
+  });
+
+  let redisAdapter: RedisAdapter;
+  let mockAdapter: IMemoryAdapter;
+  let redisClient: Redis | null = null;
+  const fixedDate = new Date("2025-01-30T07:43:50.626Z");
+  const fixedDateString = fixedDate.toISOString();
+
+  const testMemory: BaseMemoryType = {
+    id: "test-id",
+    data: "test data",
+    roomId: "test-room",
+    createdAt: new Date(fixedDateString),
+  };
+
+  beforeEach(async function () {
+    this.timeout(10000);
+
+    try {
+      mockAdapter = {
+        init: async () => {},
+        createMemory: async (input) => testMemory,
+        getMemoryById: async () => testMemory,
+        getMemoryByIndex: async () => [testMemory],
+        getAllMemories: async () => [testMemory],
+        clearMemoryById: async () => {},
+        clearAllMemories: async () => {},
+      };
+
+      if (process.env.REDIS_URL) {
+        redisClient = new Redis(process.env.REDIS_URL);
+        redisAdapter = new RedisAdapter(process.env.REDIS_URL, {
+          cachePrefix: "test-prefix",
+          cacheTTL: 3600,
+        });
+      } else {
+        const mockRedis = {
+          connect: async () => Promise.resolve(),
+          disconnect: async () => Promise.resolve(),
+          set: async () => "OK",
+          get: async (key: string) => {
+            if (key.includes("test-id")) {
+              return JSON.stringify({
+                id: "test-id",
+                data: "test data",
+                embedding: null,
+                roomId: "test-room",
+                createdAt: fixedDateString,
+              });
+            }
+            return null;
+          },
+          keys: async () => [`test-id`],
+          mget: async (keys: string[]) =>
+            keys.map(() =>
+              JSON.stringify({
+                id: "test-id",
+                data: "test data",
+                embedding: null,
+                roomId: "test-room",
+                createdAt: fixedDateString,
+              })
+            ),
+          del: async () => 1,
+          flushall: async () => "OK",
+          quit: async () => Promise.resolve(),
+        };
+
+        redisAdapter = new RedisAdapter(mockRedis as any, {
+          cachePrefix: "test-prefix",
+          cacheTTL: 3600,
+        });
+      }
+
+      await redisAdapter.init("test-room");
+    } catch (error) {
+      console.error("Error in beforeEach:", error);
+      throw error;
+    }
+  });
+
+  afterEach(async function () {
+    this.timeout(5000);
+    try {
+      if (redisClient) {
+        await redisClient.quit();
+        redisClient = null;
+      }
+      if (redisAdapter) {
+        await redisAdapter.quit();
+      }
+    } catch (error) {
+      console.error("Error in afterEach:", error);
+    }
+  });
+
+  describe("Initialization", () => {
+    it("should initialize storage", async () => {
+      await expect(redisAdapter.init("test-room")).to.not.throw;
+    });
+  });
+
+  describe("Memory Operations", () => {
+    const TEST_ROOM_ID = "test-room";
+
+    it("should create memory", async () => {
+      await expect(
+        redisAdapter.createMemory({
+          data: "test data",
+          roomId: TEST_ROOM_ID,
+          id: "test-id",
+          embedding: [0.1, 0.2, 0.3],
+        })
+      ).to.not.throw;
+    });
+
+    it("should get memory by ID", async () => {
+      const result = await redisAdapter.getMemoryById("test-id", TEST_ROOM_ID);
+      if (result) {
+        result.createdAt = new Date(fixedDateString);
+      }
+      expect(result).to.deep.equal(testMemory);
+    });
+
+    it("should get memories by index", async () => {
+      const results = await redisAdapter.getMemoryByIndex("test", {
+        roomId: TEST_ROOM_ID,
+        limit: 10,
+      });
+
+      expect(results).to.be.an("array");
+      if (results[0]) {
+        results[0].createdAt = new Date(fixedDateString);
+      }
+      expect(results[0]).to.deep.equal(testMemory);
+    });
+
+    it("should get all memories", async () => {
+      const results = await redisAdapter.getAllMemories(TEST_ROOM_ID);
+      expect(results).to.be.an("array");
+      if (results[0]) {
+        results[0].createdAt = new Date(fixedDateString);
+      }
+      expect(results[0]).to.deep.equal(testMemory);
+    });
+
+    it("should clear memory by ID", async () => {
+      await expect(redisAdapter.clearMemoryById("test-id", TEST_ROOM_ID)).to.not
+        .throw;
+    });
+
+    it("should clear all memories", async () => {
+      await expect(redisAdapter.clearAllMemories()).to.not.throw;
+    });
+  });
+});

package/test/modules/memory/base.test.ts

@@ -0,0 +1,230 @@
+import { expect } from "chai";
+import { IMemoryAdapter } from "../../../interfaces";
+import { Memory } from "../../../modules/memory";
+import { BaseMemoryType, CreateMemoryInput } from "../../../types";
+
+/**
+ * @module MemoryTests
+ * @description Test suite for the Memory service implementation.
+ * Tests the core functionality of memory management including:
+ * - Initialization
+ * - Memory creation
+ * - Memory retrieval
+ * - Memory deletion
+ */
+
+describe("Memory", () => {
+  let memory: Memory;
+  let mockAdapter: IMemoryAdapter;
+  const TEST_ROOM_ID = "test-room";
+
+  /**
+   * Test data fixture
+   * @type {BaseMemoryType}
+   */
+  const testMemory: BaseMemoryType = {
+    id: "test-id",
+    data: "test data",
+    embedding: [0.1, 0.2, 0.3],
+    roomId: TEST_ROOM_ID,
+    createdAt: new Date(),
+  };
+
+  /**
+   * Set up test environment before each test
+   * Creates a mock adapter and initializes the memory service
+   */
+  beforeEach(() => {
+    // Create mock implementation of IMemoryAdapter
+    mockAdapter = {
+      init: async () => Promise.resolve(),
+      createMemory: async (input: CreateMemoryInput) => ({
+        ...testMemory,
+        data: input.data,
+        embedding: input.embedding,
+      }),
+      getMemoryById: async () => testMemory,
+      getMemoryByIndex: async () => [testMemory],
+      getAllMemories: async () => [testMemory],
+      clearMemoryById: async () => Promise.resolve(),
+      clearAllMemories: async () => Promise.resolve(),
+    };
+
+    memory = new Memory(mockAdapter);
+  });
+
+  /**
+   * Test suite for initialization functionality
+   */
+  describe("Initialization", () => {
+    /**
+     * Test case: Verify adapter initialization
+     */
+    it("should initialize the memory adapter", async () => {
+      let initCalled = false;
+      mockAdapter.init = async () => {
+        initCalled = true;
+      };
+
+      await memory.init();
+      expect(initCalled).to.be.true;
+    });
+  });
+
+  /**
+   * Test suite for memory creation functionality
+   */
+  describe("Memory Creation", () => {
+    /**
+     * Test case: Verify memory creation with valid input
+     */
+    it("should create a new memory entry", async () => {
+      const input = {
+        data: "test data",
+        roomId: TEST_ROOM_ID,
+      };
+
+      const result = await memory.createMemory(input);
+      expect(result).to.deep.include(input);
+    });
+
+    /**
+     * Test case: Verify memory creation with embedding
+     */
+    it("should create a memory entry with embedding", async () => {
+      const input = {
+        data: "test data",
+        roomId: TEST_ROOM_ID,
+        embedding: [0.1, 0.2, 0.3],
+      };
+
+      const result = await memory.createMemory(input);
+      expect(result).to.deep.include(input);
+    });
+  });
+
+  /**
+   * Test suite for memory retrieval functionality
+   */
+  describe("Memory Retrieval", () => {
+    /**
+     * Test case: Verify memory retrieval by ID
+     */
+    it("should retrieve a memory by ID", async () => {
+      const result = await memory.getMemoryById("test-id", TEST_ROOM_ID);
+      expect(result).to.deep.equal(testMemory);
+    });
+
+    /**
+     * Test case: Verify memory retrieval by index
+     */
+    it("should retrieve memories by index", async () => {
+      const result = await memory.getMemoryByIndex("test", {
+        roomId: TEST_ROOM_ID,
+      });
+      expect(result).to.deep.equal([testMemory]);
+    });
+
+    /**
+     * Test case: Verify retrieval of all memories
+     */
+    it("should retrieve all memories", async () => {
+      const result = await memory.getAllMemories(TEST_ROOM_ID);
+      expect(result).to.deep.equal([testMemory]);
+    });
+  });
+
+  /**
+   * Test suite for memory deletion functionality
+   */
+  describe("Memory Deletion", () => {
+    /**
+     * Test case: Verify memory deletion by ID
+     */
+    it("should delete a memory by ID", async () => {
+      let deleteCalled = false;
+      mockAdapter.clearMemoryById = async () => {
+        deleteCalled = true;
+      };
+
+      await memory.clearMemoryById("test-id", TEST_ROOM_ID);
+      expect(deleteCalled).to.be.true;
+    });
+
+    /**
+     * Test case: Verify deletion of all memories
+     */
+    it("should clear all memories", async () => {
+      let clearAllCalled = false;
+      mockAdapter.clearAllMemories = async () => {
+        clearAllCalled = true;
+      };
+
+      await memory.clearAllMemories();
+      expect(clearAllCalled).to.be.true;
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle errors during memory creation", async () => {
+      mockAdapter.createMemory = async () => {
+        throw new Error("Creation failed");
+      };
+
+      try {
+        await memory.createMemory({
+          data: "test",
+          roomId: TEST_ROOM_ID,
+        });
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).to.be.instanceOf(Error);
+        expect((error as Error).message).to.equal("Creation failed");
+      }
+    });
+
+    it("should handle errors during memory retrieval", async () => {
+      mockAdapter.getMemoryById = async () => {
+        throw new Error("Retrieval failed");
+      };
+
+      try {
+        await memory.getMemoryById("test-id", TEST_ROOM_ID);
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).to.be.instanceOf(Error);
+        expect((error as Error).message).to.equal("Retrieval failed");
+      }
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle undefined embedding", async () => {
+      const input = {
+        data: "test data",
+        query: "test query",
+        roomId: "test-room",
+        embedding: undefined,
+      };
+
+      const result = await memory.createMemory(input);
+      expect(result?.embedding).to.be.null;
+    });
+
+    it("should handle empty query results", async () => {
+      mockAdapter.getMemoryByIndex = async () => [];
+
+      const results = await memory.getMemoryByIndex("nonexistent", {
+        roomId: "test-room",
+      });
+      expect(results).to.be.an("array").that.is.empty;
+    });
+
+    it("should handle non-existent memory ID", async () => {
+      mockAdapter.getMemoryById = async () => null;
+
+      const result = await memory.getMemoryById("nonexistent", TEST_ROOM_ID);
+      expect(result).to.be.null;
+    });
+  });
+});