@ai.ntellect/core 0.4.1 → 0.6.0

package/test/memory/adapters/meilisearch.test.ts

@@ -0,0 +1,297 @@
+import { BaseMemoryService } from "@/interfaces";
+import { MeilisearchAdapter } from "@/memory/adapters/meilisearch";
+import { BaseMemoryType } from "@/types";
+import { expect } from "chai";
+import dotenv from "dotenv";
+
+// 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();
+
+        // 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 for settings
+        if (url.includes("/settings")) {
+          return new Response(JSON.stringify({ acknowledged: true }));
+        }
+
+        // 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]));
+        }
+
+        return new Response(JSON.stringify({}));
+      };
+
+      mockBaseMemoryService = {
+        initializeConnection: async () => {},
+        createMemory: async () => {},
+        getMemoryById: async () => testMemory,
+        getMemoryByIndex: async () => [testMemory],
+        getAllMemories: async () => [testMemory],
+        clearMemoryById: async () => {},
+        clearAllMemories: async () => {},
+      };
+
+      meilisearchAdapter = new MeilisearchAdapter(
+        {
+          host: "http://localhost:7700",
+          apiKey: "aSampleMasterKey",
+          searchableAttributes: ["content"],
+          sortableAttributes: ["createdAt"],
+        },
+        mockBaseMemoryService
+      );
+    }
+  });
+
+  describe("Initialization", () => {
+    it("should initialize storage", async () => {
+      await expect(meilisearchAdapter.init()).to.not.throw;
+    });
+  });
+
+  describe("Memory Operations", () => {
+    beforeEach(async () => {
+      // Reset fetch mock for each test
+      if (!process.env.MEILISEARCH_HOST) {
+        global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+          const url = input.toString();
+
+          // 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 for settings
+          if (url.includes("/settings")) {
+            return new Response(JSON.stringify({ acknowledged: true }));
+          }
+
+          // 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]));
+          }
+
+          return new Response(JSON.stringify({}));
+        };
+      }
+
+      try {
+        await meilisearchAdapter.init();
+        await meilisearchAdapter.initializeStorage(TEST_ROOM_ID);
+      } catch (error) {
+        console.error("Failed to initialize:", error);
+        throw error;
+      }
+    });
+
+    it("should create memory", async () => {
+      const result = await meilisearchAdapter.createMemory({
+        data: "test data",
+        query: "test query",
+        roomId: TEST_ROOM_ID,
+      });
+
+      expect(result).to.exist;
+      expect(result?.data).to.equal("test data");
+      expect(result?.embedding).to.be.null;
+    });
+
+    it("should search memories", async () => {
+      const results = await meilisearchAdapter.getMemoryByIndex("test", {
+        roomId: TEST_ROOM_ID,
+        limit: 10,
+      });
+
+      expect(results).to.be.an("array");
+      if (results.length > 0) {
+        const result = results[0];
+        if (result) {
+          result.createdAt = new Date(result.createdAt);
+        }
+        expect(result).to.deep.equal(testMemory);
+      }
+    });
+
+    it("should handle memory retrieval by ID", async () => {
+      global.fetch = async (input: RequestInfo | URL) => {
+        const url = input.toString();
+        if (url.includes(`/indexes/${TEST_ROOM_ID}/documents/test-id`)) {
+          return new Response(
+            JSON.stringify({
+              ...testMemory,
+              createdAt: testMemory.createdAt.toISOString(),
+            })
+          );
+        }
+        return new Response(JSON.stringify({}));
+      };
+
+      const result = await meilisearchAdapter.getMemoryById(
+        "test-id",
+        TEST_ROOM_ID
+      );
+      if (result) {
+        result.createdAt = new Date(result.createdAt);
+      }
+      expect(result).to.deep.equal(testMemory);
+    });
+
+    it("should handle non-existent memory", async () => {
+      global.fetch = async (): Promise<Response> => {
+        throw new Error("Not found");
+      };
+
+      const result = await meilisearchAdapter.getMemoryById(
+        "non-existent",
+        TEST_ROOM_ID
+      );
+      expect(result).to.be.null;
+    });
+
+    it("should clear all memories", async () => {
+      await expect(meilisearchAdapter.clearAllMemories()).to.not.throw;
+    });
+
+    it("should not create duplicate memory with same data", async () => {
+      // Create first memory
+      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);
+    });
+
+    it("should initialize storage", async () => {
+      global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = input.toString();
+
+        // Mock pour la vérification de l'existence de l'index
+        if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
+          return new Response(
+            JSON.stringify({
+              uid: TEST_ROOM_ID,
+              primaryKey: "id",
+            })
+          );
+        }
+
+        // Mock pour les settings
+        if (url.includes("/settings")) {
+          return new Response(JSON.stringify({ acknowledged: true }));
+        }
+
+        return new Response(JSON.stringify({}));
+      };
+
+      await expect(meilisearchAdapter.initializeStorage(TEST_ROOM_ID)).to.not
+        .throw;
+    });
+  });
+});

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

@@ -0,0 +1,160 @@
+import { BaseMemoryService } from "@/interfaces";
+import { RedisAdapter } from "@/memory/adapters/redis";
+import { BaseMemoryType } from "@/types";
+import { expect } from "chai";
+import dotenv from "dotenv";
+import Redis from "ioredis";
+
+// Load environment variables
+dotenv.config();
+
+describe("RedisAdapter", () => {
+  before(function () {
+    this.timeout(15000);
+  });
+
+  let redisAdapter: RedisAdapter;
+  let mockBaseMemoryService: BaseMemoryService;
+  let redisClient: Redis | null = null;
+  const fixedDate = new Date("2025-01-30T07:43:50.626Z");
+
+  const testMemory: BaseMemoryType = {
+    id: "test-id",
+    data: "test data",
+    query: "test query",
+    embedding: [0.1, 0.2, 0.3],
+    roomId: "test-room",
+    createdAt: fixedDate,
+  };
+
+  beforeEach(async () => {
+    mockBaseMemoryService = {
+      initializeConnection: async () => {},
+      createMemory: async () => {},
+      getMemoryById: async () => testMemory,
+      getMemoryByIndex: async () => [testMemory],
+      getAllMemories: async () => [testMemory],
+      clearMemoryById: async () => {},
+      clearAllMemories: async () => {},
+    };
+
+    // Use real Redis if environment variables are set, otherwise mock
+    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 {
+      // Mock Redis implementation
+      const mockRedis = {
+        connect: async () => {},
+        disconnect: async () => {},
+        set: async (key: string, value: string) => "OK",
+        get: async (key: string) => {
+          if (key.includes("test-id")) {
+            return JSON.stringify({
+              ...testMemory,
+              createdAt: fixedDate.toISOString(),
+            });
+          }
+          return null;
+        },
+        keys: async (pattern: string) => {
+          return [`${pattern}test-id`];
+        },
+        mget: async (keys: string[]) => {
+          return keys.map(() =>
+            JSON.stringify({
+              ...testMemory,
+              createdAt: fixedDate.toISOString(),
+            })
+          );
+        },
+        del: async () => 1,
+        flushall: async () => "OK",
+        quit: async () => {},
+      };
+
+      redisAdapter = new RedisAdapter(mockRedis as any, {
+        cachePrefix: "test-prefix",
+        cacheTTL: 3600,
+      });
+    }
+
+    await redisAdapter.initializeConnection();
+  });
+
+  afterEach(async () => {
+    if (redisClient) {
+      await redisClient.quit();
+      redisClient = null;
+    }
+    // @ts-ignore pour éviter l'erreur de typage
+    await redisAdapter?.quit?.();
+  });
+
+  describe("Initialization", () => {
+    it("should initialize storage", async () => {
+      await expect(redisAdapter.initializeConnection()).to.not.throw;
+    });
+  });
+
+  describe("Memory Operations", () => {
+    const TEST_ROOM_ID = "test-room";
+
+    it("should create memory", async () => {
+      await expect(
+        redisAdapter.createMemory({
+          data: "test data",
+          query: "test query",
+          roomId: TEST_ROOM_ID,
+          id: "test-id",
+          embedding: [0.1, 0.2, 0.3],
+          createdAt: fixedDate,
+        })
+      ).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(result.createdAt);
+      }
+      expect(result).to.deep.equal({
+        ...testMemory,
+        createdAt: testMemory.createdAt,
+      });
+    });
+
+    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(results[0].createdAt);
+      }
+      expect(results[0]).to.deep.equal(testMemory);
+    });
+
+    it("should get all memories", async () => {
+      const results = await redisAdapter.getAllMemories();
+      expect(results).to.be.an("array");
+      if (results[0]) {
+        results[0].createdAt = new Date(results[0].createdAt);
+      }
+      expect(results[0]).to.deep.equal(testMemory);
+    });
+
+    it("should clear memory by ID", async () => {
+      await expect(redisAdapter.clearMemoryById("test-id")).to.not.throw;
+    });
+
+    it("should clear all memories", async () => {
+      await expect(redisAdapter.clearAllMemories()).to.not.throw;
+    });
+  });
+});

package/test/memory/base.test.ts

@@ -0,0 +1,229 @@
+import { BaseMemoryService } from "@/interfaces";
+import { BaseMemory } from "@/memory";
+import { BaseMemoryType, CreateMemoryInput } from "@/types";
+import { expect } from "chai";
+
+/**
+ * Test suite for the BaseMemory service
+ * This suite tests the memory management system that handles storage and retrieval of memory entries
+ */
+
+// Classe concrète pour tester BaseMemory
+class TestMemory extends BaseMemory {
+  async init(): Promise<void> {
+    await this.cacheService.initializeConnection();
+  }
+
+  async createMemory(
+    input: CreateMemoryInput & { embedding?: number[] }
+  ): Promise<BaseMemoryType | undefined> {
+    const memory: BaseMemoryType = {
+      id: crypto.randomUUID(),
+      data: input.data,
+      query: input.query,
+      embedding: input.embedding || null,
+      roomId: input.roomId,
+      createdAt: new Date(),
+    };
+    await this.cacheService.createMemory(memory, input.ttl);
+    return memory;
+  }
+
+  async getMemoryById(
+    id: string,
+    roomId: string
+  ): Promise<BaseMemoryType | null> {
+    return this.cacheService.getMemoryById(id);
+  }
+
+  async getMemoryByIndex(
+    query: string,
+    options: { roomId: string; limit?: number }
+  ): Promise<BaseMemoryType[]> {
+    return this.cacheService.getMemoryByIndex(query, options);
+  }
+
+  async getAllMemories(roomId: string): Promise<BaseMemoryType[]> {
+    return this.cacheService.getAllMemories();
+  }
+
+  async clearMemoryById(id: string, roomId: string): Promise<void> {
+    await this.cacheService.clearMemoryById(id);
+  }
+
+  async clearAllMemories(): Promise<void> {
+    await this.cacheService.clearAllMemories();
+  }
+}
+
+describe("BaseMemory", () => {
+  let memory: TestMemory;
+  let mockMemoryService: BaseMemoryService;
+  const TEST_ROOM_ID = "test-room";
+
+  // Mock data for testing
+  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(() => {
+    // Create mock implementation of BaseMemoryService
+    mockMemoryService = {
+      initializeConnection: async () => Promise.resolve(),
+      createMemory: async (memory: BaseMemoryType) => Promise.resolve(),
+      getMemoryById: async (id: string) => Promise.resolve(testMemory),
+      getMemoryByIndex: async (query: string, options: any) =>
+        Promise.resolve([testMemory]),
+      getAllMemories: async () => Promise.resolve([testMemory]),
+      clearMemoryById: async (id: string) => Promise.resolve(),
+      clearAllMemories: async () => Promise.resolve(),
+    };
+
+    memory = new TestMemory(mockMemoryService);
+  });
+
+  describe("Initialization", () => {
+    it("should initialize the memory service", async () => {
+      let initCalled = false;
+      mockMemoryService.initializeConnection = async () => {
+        initCalled = true;
+      };
+
+      await memory.init();
+      expect(initCalled).to.be.true;
+    });
+  });
+
+  describe("Memory Creation", () => {
+    it("should create a new memory entry", async () => {
+      const input = {
+        data: "test data",
+        query: "test query",
+        roomId: "test-room",
+        ttl: 3600,
+      };
+
+      const result = await memory.createMemory(input);
+
+      expect(result).to.exist;
+      expect(result?.data).to.equal(input.data);
+      expect(result?.query).to.equal(input.query);
+      expect(result?.roomId).to.equal(input.roomId);
+      expect(result?.id).to.be.a("string");
+    });
+
+    it("should create memory with embedding", async () => {
+      const input = {
+        data: "test data",
+        query: "test query",
+        roomId: "test-room",
+        embedding: [0.1, 0.2, 0.3],
+      };
+
+      const result = await memory.createMemory(input);
+
+      expect(result?.embedding).to.deep.equal(input.embedding);
+    });
+  });
+
+  describe("Memory Retrieval", () => {
+    it("should retrieve memory by ID", async () => {
+      const result = await memory.getMemoryById("test-id", TEST_ROOM_ID);
+      expect(result).to.deep.equal(testMemory);
+    });
+
+    it("should retrieve memories by index", async () => {
+      const results = await memory.getMemoryByIndex("test query", {
+        roomId: "test-room",
+        limit: 10,
+      });
+
+      expect(results).to.be.an("array");
+      expect(results[0]).to.deep.equal(testMemory);
+    });
+
+    it("should retrieve all memories", async () => {
+      const results = await memory.getAllMemories(TEST_ROOM_ID);
+      expect(results).to.be.an("array");
+    });
+  });
+
+  describe("Memory Clearing", () => {
+    it("should clear memory by ID", async () => {
+      await memory.clearMemoryById("test-id", TEST_ROOM_ID);
+    });
+
+    it("should clear all memories", async () => {
+      await memory.clearAllMemories();
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle errors during memory creation", async () => {
+      mockMemoryService.createMemory = async () => {
+        throw new Error("Creation failed");
+      };
+
+      try {
+        await memory.createMemory({
+          data: "test",
+          query: "test",
+          roomId: "test",
+        });
+        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 () => {
+      mockMemoryService.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 () => {
+      mockMemoryService.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 () => {
+      mockMemoryService.getMemoryById = async () => null;
+
+      const result = await memory.getMemoryById("nonexistent", TEST_ROOM_ID);
+      expect(result).to.be.null;
+    });
+  });
+});