test: cleaned up tests and added test to ignore duplicates

packages/core/tests/StorageContext.test.ts

-import { storageContextFromDefaults } from "llamaindex/storage/StorageContext";
+import {
+  storageContextFromDefaults,
+  type StorageContext,
+} from "llamaindex/storage/StorageContext";
 import { existsSync, rmSync } from "node:fs";
-import { describe, expect, test, vi, vitest } from "vitest";
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  expect,
+  test,
+  vi,
+  vitest,
+} from "vitest";
 
 vitest.spyOn(console, "error");
 
 describe("StorageContext", () => {
-  test("initializes", async () => {
-    vi.mocked(console.error).mockImplementation(() => {}); // silence console.error
+  let storageContext: StorageContext;
 
-    const storageContext = await storageContextFromDefaults({
+  beforeAll(async () => {
+    storageContext = await storageContextFromDefaults({
       persistDir: "/tmp/test_dir",
     });
+  });
+
+  test("initializes", async () => {
+    vi.mocked(console.error).mockImplementation(() => {}); // silence console.error
 
     expect(existsSync("/tmp/test_dir")).toBe(true);
     expect(storageContext).toBeDefined();
+  });
 
-    // cleanup
+  afterAll(() => {
     rmSync("/tmp/test_dir", { recursive: true });
   });
 });

packages/core/tests/indices/SummaryIndex.test.ts

-import type { ServiceContext } from "llamaindex";
 import {
   Document,
-  OpenAI,
-  OpenAIEmbedding,
   SummaryIndex,
   VectorStoreIndex,
-  serviceContextFromDefaults,
   storageContextFromDefaults,
+  type ServiceContext,
+  type StorageContext,
 } from "llamaindex";
-import { beforeAll, describe, expect, it, vi } from "vitest";
-import {
-  mockEmbeddingModel,
-  mockLlmGeneration,
-} from "../utility/mockOpenAI.js";
-
-// Mock the OpenAI getOpenAISession function during testing
-vi.mock("llamaindex/llm/open_ai", () => {
-  return {
-    getOpenAISession: vi.fn().mockImplementation(() => null),
-  };
-});
+import { rmSync } from "node:fs";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { mockServiceContext } from "../utility/mockServiceContext.js";
 
 describe("SummaryIndex", () => {
   let serviceContext: ServiceContext;
+  let storageContext: StorageContext;
 
-  beforeAll(() => {
-    const embeddingModel = new OpenAIEmbedding();
-    const llm = new OpenAI();
-
-    mockEmbeddingModel(embeddingModel);
-    mockLlmGeneration({ languageModel: llm });
-
-    const ctx = serviceContextFromDefaults({
-      embedModel: embeddingModel,
-      llm,
+  beforeAll(async () => {
+    serviceContext = mockServiceContext();
+    storageContext = await storageContextFromDefaults({
+      persistDir: "/tmp/test_dir",
     });
-
-    serviceContext = ctx;
   });
 
   it("SummaryIndex and VectorStoreIndex must be able to share the same storage context", async () => {
-    const storageContext = await storageContextFromDefaults({
-      persistDir: "/tmp/test_dir",
-    });
     const documents = [new Document({ text: "lorem ipsem", id_: "1" })];
     const vectorIndex = await VectorStoreIndex.fromDocuments(documents, {
       serviceContext,
@@ -55,4 +34,8 @@ describe("SummaryIndex", () => {
     });
     expect(summaryIndex).toBeDefined();
   });
+
+  afterAll(() => {
+    rmSync("/tmp/test_dir", { recursive: true });
+  });
 });

packages/core/tests/indices/VectorStoreIndex.test.ts

+import type { ServiceContext, StorageContext } from "llamaindex";
+import {
+  Document,
+  VectorStoreIndex,
+  storageContextFromDefaults,
+} from "llamaindex";
+import { beforeAll, describe, expect, test } from "vitest";
+import { mockServiceContext } from "../utility/mockServiceContext.js";
+
+describe.sequential("VectorStoreIndex", () => {
+  let serviceContext: ServiceContext;
+  let storageContext: StorageContext;
+  let testStrategy: (
+    // strategy?: DocStoreStrategy,
+    runs?: number,
+  ) => Promise<Array<number>>;
+
+  beforeAll(async () => {
+    serviceContext = mockServiceContext();
+    storageContext = await storageContextFromDefaults({
+      persistDir: "/tmp/test_dir",
+    });
+    testStrategy = async (
+      // strategy?: DocStoreStrategy,
+      runs: number = 2,
+    ): Promise<Array<number>> => {
+      const documents = [new Document({ text: "lorem ipsem", id_: "1" })];
+      const entries = [];
+      for (let i = 0; i < runs; i++) {
+        await VectorStoreIndex.fromDocuments(documents, {
+          serviceContext,
+          storageContext,
+          // docStoreStrategy: strategy,
+        });
+        const docs = await storageContext.docStore.docs();
+        entries.push(Object.keys(docs).length);
+      }
+      return entries;
+    };
+  });
+
+  test("fromDocuments does not stores duplicates per default", async () => {
+    const entries = await testStrategy();
+    expect(entries[0]).toBe(entries[1]);
+  });
+
+  // test("fromDocuments ignores duplicates in upserts", async () => {
+  //   const entries = await testStrategy(DocStoreStrategy.DUPLICATES_ONLY);
+  //   expect(entries[0]).toBe(entries[1]);
+  // });
+
+  // afterAll(() => {
+  //   rmSync("/tmp/test_dir", { recursive: true });
+  // });
+});

packages/core/tests/objects/ObjectIndex.test.ts

@@ -2,40 +2,17 @@ import type { ServiceContext } from "llamaindex";
 import {
   FunctionTool,
   ObjectIndex,
-  OpenAI,
-  OpenAIEmbedding,
   SimpleToolNodeMapping,
   VectorStoreIndex,
-  serviceContextFromDefaults,
 } from "llamaindex";
-import { beforeAll, describe, expect, test, vi } from "vitest";
-import {
-  mockEmbeddingModel,
-  mockLlmGeneration,
-} from "../utility/mockOpenAI.js";
-
-vi.mock("llamaindex/llm/open_ai", () => {
-  return {
-    getOpenAISession: vi.fn().mockImplementation(() => null),
-  };
-});
+import { beforeAll, describe, expect, test } from "vitest";
+import { mockServiceContext } from "../utility/mockServiceContext.js";
 
 describe("ObjectIndex", () => {
   let serviceContext: ServiceContext;
 
   beforeAll(() => {
-    const embeddingModel = new OpenAIEmbedding();
-    const llm = new OpenAI();
-
-    mockEmbeddingModel(embeddingModel);
-    mockLlmGeneration({ languageModel: llm });
-
-    const ctx = serviceContextFromDefaults({
-      embedModel: embeddingModel,
-      llm,
-    });
-
-    serviceContext = ctx;
+    serviceContext = mockServiceContext();
   });
 
   test("test_object_with_tools", async () => {

packages/core/tests/utility/mockServiceContext.ts

+import {
+  OpenAI,
+  OpenAIEmbedding,
+  serviceContextFromDefaults,
+} from "llamaindex";
+
+import {
+  mockEmbeddingModel,
+  mockLlmGeneration,
+} from "../utility/mockOpenAI.js";
+
+import { vi } from "vitest";
+
+// Mock the OpenAI getOpenAISession function during testing
+vi.mock("llamaindex/llm/open_ai", () => {
+  return {
+    getOpenAISession: vi.fn().mockImplementation(() => null),
+  };
+});
+
+export function mockServiceContext() {
+  const embeddingModel = new OpenAIEmbedding();
+  const llm = new OpenAI();
+
+  mockEmbeddingModel(embeddingModel);
+  mockLlmGeneration({ languageModel: llm });
+
+  return serviceContextFromDefaults({
+    embedModel: embeddingModel,
+    llm,
+  });
+}