Add cluster integration tests with testcontainers (#44)

* Add cluster integration tests with testcontainers

* Removed beforeAll dep

* Ignore integration tests for unit tests

Author: 0xJaksun

package.json

@@ -5,6 +5,7 @@
   "scripts": {
     "typecheck": "pnpm -r typecheck",
     "test": "pnpm -r test",
+    "test:integration": "pnpm -r test:integration",
     "build": "pnpm -r build"
   },
   "engines": {

packages/postgres/package.json

@@ -28,11 +28,15 @@
       "require": "./dist/index.cjs"
     }
   },
-  "files": ["dist", "src/migrations"],
+  "files": [
+    "dist",
+    "src/migrations"
+  ],
   "scripts": {
     "build": "tsup && tsc --emitDeclarationOnly --outDir dist",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "test:integration": "vitest run -c vitest.integration.config.ts",
     "test:watch": "vitest"
   },
   "dependencies": {
@@ -41,6 +45,8 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@testcontainers/postgresql": "^12.0.1",
+    "testcontainers": "^12.0.1",
     "tsup": "^8.5.1",
     "typescript": "6.0.3",
     "vitest": "4.1.5"

packages/postgres/src/cluster/cluster.integration.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect } from "vitest";
+import { NotFoundError } from "@lithium-ai/core";
+import { PostgresClusterAdapter } from "./cluster.port";
+import { createClusterService } from "@lithium-ai/core";
+import { setupTestDb } from "../test/setup";
+
+describe("Cluster Integration", async () => {
+  const clusterService = createClusterService(
+    new PostgresClusterAdapter(await setupTestDb())
+  );
+
+  it("should create a root cluster with correct shape", async () => {
+    // Arrange
+    const name = crypto.randomUUID();
+
+    // Act
+    const result = await clusterService.create({ name });
+
+    // Assert
+    expect(result).toEqual({
+      success: true,
+      value: {
+        id: expect.any(String),
+        parentId: null,
+        path: name,
+        name,
+        description: null,
+        createdAt: expect.any(Date),
+      },
+    });
+  });
+
+  it("should retrieve a created cluster by path", async () => {
+    // Arrange
+    const name = crypto.randomUUID();
+    const created = await clusterService.create({ name });
+
+    // Act
+    const found = await clusterService.findByPath({ path: name });
+
+    // Assert
+    expect(found).toEqual(created);
+  });
+
+  it("should build child path as parentPath.name", async () => {
+    // Arrange
+    const parentName = crypto.randomUUID();
+    const childName = crypto.randomUUID();
+    await clusterService.create({ name: parentName });
+
+    // Act
+    const child = await clusterService.create({
+      name: childName,
+      parentPath: parentName,
+    });
+
+    // Assert
+    expect(child).toEqual({
+      success: true,
+      value: expect.objectContaining({
+        path: `${parentName}.${childName}`,
+        name: childName,
+      }),
+    });
+  });
+
+  it("should set parentId to the parent cluster ID", async () => {
+    // Arrange
+    const parentName = crypto.randomUUID();
+    const parent = await clusterService.create({ name: parentName });
+    if (!parent.success) throw new Error("Parent creation failed");
+
+    // Act
+    const child = await clusterService.create({
+      name: crypto.randomUUID(),
+      parentPath: parentName,
+    });
+
+    // Assert
+    expect(child).toEqual({
+      success: true,
+      value: expect.objectContaining({
+        parentId: parent.value.id,
+      }),
+    });
+  });
+
+  it("should include created cluster in list results with correct shape", async () => {
+    // Arrange
+    const name = crypto.randomUUID();
+    const created = await clusterService.create({ name });
+    if (!created.success) throw new Error("Create failed");
+
+    // Act
+    const result = await clusterService.list();
+    if (!result.success) throw new Error("List failed");
+
+    // Assert
+    expect(result.value).toContainEqual(created.value);
+  });
+
+  it("should return exact descendant IDs for parent and child", async () => {
+    // Arrange
+    const parentName = crypto.randomUUID();
+    const childName = crypto.randomUUID();
+    const parent = await clusterService.create({ name: parentName });
+    if (!parent.success) throw new Error("Parent creation failed");
+    const child = await clusterService.create({
+      name: childName,
+      parentPath: parentName,
+    });
+    if (!child.success) throw new Error("Child creation failed");
+
+    // Act
+    const result = await clusterService.listDescendantIds({ path: parentName });
+
+    // Assert
+    expect(result).toEqual({
+      success: true,
+      value: expect.arrayContaining([parent.value.id, child.value.id]),
+    });
+  });
+
+  it("should not include unrelated clusters in descendant IDs", async () => {
+    // Arrange
+    const parentName = crypto.randomUUID();
+    const unrelatedName = crypto.randomUUID();
+    const parent = await clusterService.create({ name: parentName });
+    if (!parent.success) throw new Error("Parent creation failed");
+    const unrelated = await clusterService.create({ name: unrelatedName });
+    if (!unrelated.success) throw new Error("Unrelated creation failed");
+
+    // Act
+    const result = await clusterService.listDescendantIds({ path: parentName });
+    if (!result.success) throw new Error("listDescendantIds failed");
+
+    // Assert
+    expect(result.value).toContain(parent.value.id);
+    expect(result.value).not.toContain(unrelated.value.id);
+  });
+
+  it("should return NotFoundError for missing parent path", async () => {
+    // Act
+    const result = await clusterService.create({
+      name: crypto.randomUUID(),
+      parentPath: "nonexistent",
+    });
+
+    // Assert
+    expect(result).toEqual({
+      success: false,
+      error: expect.any(NotFoundError),
+    });
+  });
+});

packages/postgres/src/test/setup.ts

@@ -0,0 +1,23 @@
+import { PostgreSqlContainer } from "@testcontainers/postgresql";
+import postgres, { type Sql } from "postgres";
+import fs from "fs";
+import path from "path";
+
+const MIGRATIONS_DIR = path.join(__dirname, "../migrations");
+
+export async function setupTestDb(): Promise<Sql> {
+  const container = await new PostgreSqlContainer("postgres:16").start();
+  const sql = postgres(container.getConnectionUri());
+
+  const migrations = fs
+    .readdirSync(MIGRATIONS_DIR)
+    .filter((f) => f.endsWith(".sql"))
+    .sort();
+
+  for (const file of migrations) {
+    const content = fs.readFileSync(path.join(MIGRATIONS_DIR, file), "utf-8");
+    await sql.unsafe(content);
+  }
+
+  return sql;
+}

packages/postgres/vitest.config.ts

@@ -3,6 +3,7 @@ import { defineConfig } from "vitest/config";
 export default defineConfig({
   test: {
     include: ["src/**/*.test.ts"],
+    exclude: ["src/**/*.integration.test.ts", "**/node_modules/**"],
     passWithNoTests: true,
   },
 });

packages/postgres/vitest.integration.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["src/**/*.integration.test.ts"],
+  },
+});