feat(#3): Add comprehensive tests and improve Prisma seed script

- Create comprehensive test suite for PrismaService (10 tests)
- Fix AppController tests with proper PrismaService mocking
- Wrap seed operations in transaction for atomicity
- Replace N+1 pattern with batch operations (createMany)
- Add concurrency warning to seed script
- All tests passing (14/14)
- Build successful
- Test coverage >85%

Fixes #3

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

apps/api/prisma/seed.ts

@@ -11,6 +11,10 @@ const prisma = new PrismaClient();
 async function main() {
   console.log("Seeding database...");
 
+  // IMPORTANT: This seed script should not be run concurrently
+  // If running in CI/CD, ensure serialization of seed operations
+  // to prevent race conditions and data corruption
+
   // Create test user
   const user = await prisma.user.upsert({
     where: { email: "dev@mosaic.local" },
@@ -59,87 +63,89 @@ async function main() {
     },
   });
 
-  // Delete existing seed data for idempotency (avoids duplicates on re-run)
-  await prisma.task.deleteMany({ where: { workspaceId: workspace.id } });
-  await prisma.event.deleteMany({ where: { workspaceId: workspace.id } });
-  await prisma.project.deleteMany({ where: { workspaceId: workspace.id } });
+  // Use transaction for atomic seed data reset and creation
+  await prisma.$transaction(async (tx) => {
+    // Delete existing seed data for idempotency (avoids duplicates on re-run)
+    await tx.task.deleteMany({ where: { workspaceId: workspace.id } });
+    await tx.event.deleteMany({ where: { workspaceId: workspace.id } });
+    await tx.project.deleteMany({ where: { workspaceId: workspace.id } });
 
-  // Create sample project
-  const project = await prisma.project.create({
-    data: {
-      workspaceId: workspace.id,
-      name: "Sample Project",
-      description: "A sample project for development",
-      status: ProjectStatus.ACTIVE,
-      creatorId: user.id,
-      color: "#3B82F6",
-    },
-  });
-
-  console.log(`Created project: ${project.name}`);
-
-  // Create sample tasks
-  const tasks = [
-    {
-      title: "Set up development environment",
-      status: TaskStatus.COMPLETED,
-      priority: TaskPriority.HIGH,
-    },
-    {
-      title: "Review project requirements",
-      status: TaskStatus.IN_PROGRESS,
-      priority: TaskPriority.MEDIUM,
-    },
-    {
-      title: "Design database schema",
-      status: TaskStatus.COMPLETED,
-      priority: TaskPriority.HIGH,
-    },
-    {
-      title: "Implement NestJS integration",
-      status: TaskStatus.COMPLETED,
-      priority: TaskPriority.HIGH,
-    },
-    {
-      title: "Create seed data",
-      status: TaskStatus.IN_PROGRESS,
-      priority: TaskPriority.MEDIUM,
-    },
-  ];
-
-  for (const taskData of tasks) {
-    await prisma.task.create({
+    // Create sample project
+    const project = await tx.project.create({
       data: {
+        workspaceId: workspace.id,
+        name: "Sample Project",
+        description: "A sample project for development",
+        status: ProjectStatus.ACTIVE,
+        creatorId: user.id,
+        color: "#3B82F6",
+      },
+    });
+
+    console.log(`Created project: ${project.name}`);
+
+    // Create sample tasks
+    const tasks = [
+      {
+        title: "Set up development environment",
+        status: TaskStatus.COMPLETED,
+        priority: TaskPriority.HIGH,
+      },
+      {
+        title: "Review project requirements",
+        status: TaskStatus.IN_PROGRESS,
+        priority: TaskPriority.MEDIUM,
+      },
+      {
+        title: "Design database schema",
+        status: TaskStatus.COMPLETED,
+        priority: TaskPriority.HIGH,
+      },
+      {
+        title: "Implement NestJS integration",
+        status: TaskStatus.COMPLETED,
+        priority: TaskPriority.HIGH,
+      },
+      {
+        title: "Create seed data",
+        status: TaskStatus.IN_PROGRESS,
+        priority: TaskPriority.MEDIUM,
+      },
+    ];
+
+    // Use createMany for batch insertion (better performance)
+    await tx.task.createMany({
+      data: tasks.map((taskData) => ({
         workspaceId: workspace.id,
         title: taskData.title,
         status: taskData.status,
         priority: taskData.priority,
         creatorId: user.id,
         projectId: project.id,
+      })),
+    });
+
+    console.log(`Created ${tasks.length} sample tasks`);
+
+    // Create sample event
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    tomorrow.setHours(10, 0, 0, 0);
+
+    await tx.event.create({
+      data: {
+        workspaceId: workspace.id,
+        title: "Morning standup",
+        description: "Daily team sync",
+        startTime: tomorrow,
+        endTime: new Date(tomorrow.getTime() + 30 * 60000), // 30 minutes later
+        creatorId: user.id,
+        projectId: project.id,
       },
     });
-  }
 
-  console.log(`Created ${tasks.length} sample tasks`);
-
-  // Create sample event
-  const tomorrow = new Date();
-  tomorrow.setDate(tomorrow.getDate() + 1);
-  tomorrow.setHours(10, 0, 0, 0);
-
-  await prisma.event.create({
-    data: {
-      workspaceId: workspace.id,
-      title: "Morning standup",
-      description: "Daily team sync",
-      startTime: tomorrow,
-      endTime: new Date(tomorrow.getTime() + 30 * 60000), // 30 minutes later
-      creatorId: user.id,
-      projectId: project.id,
-    },
+    console.log("Created sample event");
   });
-
-  console.log("Created sample event");
   console.log("Seeding completed successfully!");
 }
 

apps/api/src/app.controller.test.ts

@@ -1,10 +1,20 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { AppService } from "./app.service";
 import { AppController } from "./app.controller";
+import { PrismaService } from "./prisma/prisma.service";
 
 describe("AppController", () => {
   const appService = new AppService();
-  const controller = new AppController(appService);
+
+  // Mock PrismaService
+  const mockPrismaService = {
+    isHealthy: vi.fn(),
+    getConnectionInfo: vi.fn(),
+    $connect: vi.fn(),
+    $disconnect: vi.fn(),
+  } as unknown as PrismaService;
+
+  const controller = new AppController(appService, mockPrismaService);
 
   describe("getHello", () => {
     it('should return "Mosaic Stack API"', () => {
@@ -13,11 +23,33 @@ describe("AppController", () => {
   });
 
   describe("getHealth", () => {
-    it("should return health status", () => {
-      const result = controller.getHealth();
+    it("should return health status", async () => {
+      // Setup mocks
+      vi.mocked(mockPrismaService.isHealthy).mockResolvedValue(true);
+      vi.mocked(mockPrismaService.getConnectionInfo).mockResolvedValue({
+        connected: true,
+        database: "mosaic",
+        version: "PostgreSQL 17",
+      });
+
+      const result = await controller.getHealth();
       expect(result.success).toBe(true);
       expect(result.data.status).toBe("healthy");
       expect(result.data.timestamp).toBeDefined();
+      expect(result.data.checks.database.status).toBe("healthy");
+    });
+
+    it("should return degraded status when database is unhealthy", async () => {
+      // Setup mocks for unhealthy state
+      vi.mocked(mockPrismaService.isHealthy).mockResolvedValue(false);
+      vi.mocked(mockPrismaService.getConnectionInfo).mockResolvedValue({
+        connected: false,
+      });
+
+      const result = await controller.getHealth();
+      expect(result.success).toBe(true);
+      expect(result.data.status).toBe("degraded");
+      expect(result.data.checks.database.status).toBe("unhealthy");
     });
   });
 });

apps/api/src/prisma/prisma.service.spec.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { PrismaService } from "./prisma.service";
+
+describe("PrismaService", () => {
+  let service: PrismaService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [PrismaService],
+    }).compile();
+
+    service = module.get<PrismaService>(PrismaService);
+  });
+
+  afterEach(async () => {
+    await service.$disconnect();
+  });
+
+  it("should be defined", () => {
+    expect(service).toBeDefined();
+  });
+
+  describe("onModuleInit", () => {
+    it("should connect to the database", async () => {
+      const connectSpy = vi
+        .spyOn(service, "$connect")
+        .mockResolvedValue(undefined);
+
+      await service.onModuleInit();
+
+      expect(connectSpy).toHaveBeenCalled();
+    });
+
+    it("should throw error if connection fails", async () => {
+      const error = new Error("Connection failed");
+      vi.spyOn(service, "$connect").mockRejectedValue(error);
+
+      await expect(service.onModuleInit()).rejects.toThrow(error);
+    });
+  });
+
+  describe("onModuleDestroy", () => {
+    it("should disconnect from the database", async () => {
+      const disconnectSpy = vi
+        .spyOn(service, "$disconnect")
+        .mockResolvedValue(undefined);
+
+      await service.onModuleDestroy();
+
+      expect(disconnectSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe("isHealthy", () => {
+    it("should return true when database is accessible", async () => {
+      vi.spyOn(service, "$queryRaw").mockResolvedValue([{ result: 1 }]);
+
+      const result = await service.isHealthy();
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when database is not accessible", async () => {
+      vi
+        .spyOn(service, "$queryRaw")
+        .mockRejectedValue(new Error("Database error"));
+
+      const result = await service.isHealthy();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getConnectionInfo", () => {
+    it("should return connection info when connected", async () => {
+      const mockResult = [
+        {
+          current_database: "test_db",
+          version: "PostgreSQL 17.0 on x86_64-linux",
+        },
+      ];
+      vi.spyOn(service, "$queryRaw").mockResolvedValue(mockResult);
+
+      const result = await service.getConnectionInfo();
+
+      expect(result).toEqual({
+        connected: true,
+        database: "test_db",
+        version: "PostgreSQL",
+      });
+    });
+
+    it("should return connected false when result is empty", async () => {
+      vi.spyOn(service, "$queryRaw").mockResolvedValue([]);
+
+      const result = await service.getConnectionInfo();
+
+      expect(result).toEqual({ connected: false });
+    });
+
+    it("should return connected false when query fails", async () => {
+      vi
+        .spyOn(service, "$queryRaw")
+        .mockRejectedValue(new Error("Query failed"));
+
+      const result = await service.getConnectionInfo();
+
+      expect(result).toEqual({ connected: false });
+    });
+
+    it("should handle version without split", async () => {
+      const mockResult = [
+        {
+          current_database: "test_db",
+          version: "PostgreSQL",
+        },
+      ];
+      vi.spyOn(service, "$queryRaw").mockResolvedValue(mockResult);
+
+      const result = await service.getConnectionInfo();
+
+      expect(result).toEqual({
+        connected: true,
+        database: "test_db",
+        version: "PostgreSQL",
+      });
+    });
+  });
+});