Skip to content

armgit / mem0

Public Imported from GitHub
0

The Memory Layer for AI Agents - Drop-in memory infrastructure for AI agents and apps. Context that persists. Built for production.

3.5 KB
Raw Blame
/// <reference types="jest" />
/**
 * FastEmbed Embedder — unit tests (mocked FastEmbed client).
 * Verifies async generator handling for embed and embedBatch.
 */

const mockInit = jest.fn();
const mockEmbed = jest.fn();

jest.mock("fastembed", () => {
  return {
    __esModule: true,
    EmbeddingModel: {
      BGESmallENV15: "fast-bge-small-en-v1.5",
    },
    FlagEmbedding: {
      init: mockInit,
    },
  };
});

import { FastEmbedEmbedder } from "../src/embeddings/fastembed";

const mockVectorBatch = [
  [0.1, 0.2],
  [0.3, 0.4],
];
const mockEmbedding = [0.1, 0.2, 0.3];

const createEmbeddingGenerator = async function* (batches: number[][][]) {
  for (const batch of batches) {
    yield batch;
  }
};

describe("FastEmbedEmbedder (unit)", () => {
  beforeEach(() => {
    mockInit.mockReset();
    mockEmbed.mockReset();

    mockInit.mockResolvedValue({
      embed: mockEmbed,
    });
  });

  it("embed() initializes lazily, normalizes newlines, and returns the first vector", async () => {
    mockEmbed.mockReturnValue(
      createEmbeddingGenerator([[mockEmbedding], mockVectorBatch]),
    );
    const embedder = new FastEmbedEmbedder({
      model: "fast-bge-small-en-v1.5",
    });

    expect(mockInit).not.toHaveBeenCalled();

    const result = await embedder.embed("Example\ntext");

    expect(mockInit).toHaveBeenCalledTimes(1);
    expect(mockInit).toHaveBeenCalledWith({
      model: "fast-bge-small-en-v1.5",
    });
    expect(mockEmbed).toHaveBeenCalledTimes(1);
    expect(mockEmbed.mock.calls[0][0]).toEqual(["Example text"]);
    expect(result).toEqual(mockEmbedding);
  });

  it("embedBatch() consumes all async embedding batches and reuses the initialized model", async () => {
    mockEmbed.mockReturnValueOnce(createEmbeddingGenerator([[mockEmbedding]]));
    mockEmbed.mockReturnValueOnce(
      createEmbeddingGenerator([[mockEmbedding], mockVectorBatch]),
    );
    const embedder = new FastEmbedEmbedder({});

    await embedder.embed("warmup");
    const result = await embedder.embedBatch([
      "first text",
      "second text",
      "third text",
    ]);

    expect(mockEmbed).toHaveBeenCalledWith([
      "first text",
      "second text",
      "third text",
    ]);
    expect(mockInit).toHaveBeenCalledTimes(1);
    expect(result).toEqual([mockEmbedding, ...mockVectorBatch]);
  });

  it("embed() throws when FastEmbed yields no embeddings", async () => {
    mockEmbed.mockReturnValue(createEmbeddingGenerator([]));
    const embedder = new FastEmbedEmbedder({});

    await expect(embedder.embed("missing")).rejects.toThrow(
      "FastEmbed embed() returned no embeddings",
    );
  });

  it("embed() retries initialization after a transient init failure", async () => {
    mockInit.mockRejectedValueOnce(new Error("transient init failure"));
    mockInit.mockResolvedValueOnce({
      embed: mockEmbed,
    });
    mockEmbed.mockReturnValue(createEmbeddingGenerator([[mockEmbedding]]));
    const embedder = new FastEmbedEmbedder({});

    await expect(embedder.embed("first attempt")).rejects.toThrow(
      "transient init failure",
    );

    const result = await embedder.embed("second attempt");

    expect(mockInit).toHaveBeenCalledTimes(2);
    expect(result).toEqual(mockEmbedding);
  });

  it("throws a clear error for an unsupported model instead of failing at init", () => {
    expect(
      () => new FastEmbedEmbedder({ model: "text-embedding-3-small" }),
    ).toThrow(/Unsupported FastEmbed model "text-embedding-3-small"/);
    expect(mockInit).not.toHaveBeenCalled();
  });
});