test: add initial unit integration and e2e coverage

Adds the initial testing baseline for the project:

   Unit coverage:
   - Zod schemas for items, assignments, movements, categories, auth, recipients, users, and assets
   - password hashing and verification helpers
   - auth role helper functions

   Integration coverage with PostgreSQL Testcontainers:
   - item use-cases: create, duplicate names, delete constraints
   - assignment use-cases: create, insufficient stock, return, double return
   - asset use-cases: available/assigned creation and lifecycle transitions
   - user use-cases: create/update, uniqueness, admin safeguards, password reset
   - category use-cases: create/update/delete constraints
   - recipient use-cases: create/update and uniqueness constraints

   E2E smoke coverage with Playwright:
   - unauthenticated redirect to login
   - seeded admin login
   - dashboard load
   - admin users page
   - inventory items page
   - assignments page

   Also configures:
   - Vitest
   - Playwright
   - PostgreSQL Testcontainers helpers
   - deterministic E2E admin bootstrap
   - test artifact ignores

   Validation:
   - bun run test: 9 files / 37 tests passed
   - bun run test:e2e: 3 passed
   - bunx tsc --noEmit: passed
   - bunx prisma validate: passed

tests/integration/use-cases/category.use-cases.test.ts

@@ -0,0 +1,111 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest"
+import type { PrismaClient } from "@/generated/prisma/client"
+import { createTestCategory, createTestItem } from "../helpers/factories"
+import {
+  resetIntegrationTestDatabase,
+  startIntegrationTestDatabase,
+  stopIntegrationTestDatabase,
+} from "../helpers/test-db"
+
+let prisma: PrismaClient
+let createCategoryUseCase: typeof import("@/use-cases/category.use-cases").createCategoryUseCase
+let updateCategoryUseCase: typeof import("@/use-cases/category.use-cases").updateCategoryUseCase
+let deleteCategoryUseCase: typeof import("@/use-cases/category.use-cases").deleteCategoryUseCase
+
+beforeAll(async () => {
+  await startIntegrationTestDatabase()
+
+  const prismaModule = await import("@/lib/prisma")
+  const categoryUseCases = await import("@/use-cases/category.use-cases")
+
+  prisma = prismaModule.prisma
+  createCategoryUseCase = categoryUseCases.createCategoryUseCase
+  updateCategoryUseCase = categoryUseCases.updateCategoryUseCase
+  deleteCategoryUseCase = categoryUseCases.deleteCategoryUseCase
+})
+
+beforeEach(async () => {
+  await resetIntegrationTestDatabase(prisma)
+})
+
+afterAll(async () => {
+  await prisma?.$disconnect()
+  await stopIntegrationTestDatabase()
+})
+
+describe("category use-cases", () => {
+  it("creates a category and rejects duplicate names", async () => {
+    await expect(createCategoryUseCase({ name: "Hardware" })).resolves.toEqual({
+      success: true,
+    })
+
+    await expect(
+      prisma.category.findUniqueOrThrow({ where: { name: "Hardware" } }),
+    ).resolves.toMatchObject({ name: "Hardware" })
+
+    await expect(createCategoryUseCase({ name: "Hardware" })).resolves.toEqual({
+      success: false,
+      errors: { name: ["Category already exists"] },
+    })
+
+    await expect(prisma.category.count()).resolves.toBe(1)
+  })
+
+  it("updates a category and rejects unchanged or duplicate names", async () => {
+    const category = await createTestCategory(prisma, { name: "Peripherals" })
+    const other = await createTestCategory(prisma, { name: "Networking" })
+
+    await expect(
+      updateCategoryUseCase({ id: category.id, name: "Accessories" }),
+    ).resolves.toEqual({ success: true })
+
+    await expect(
+      prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
+    ).resolves.toMatchObject({ name: "Accessories" })
+
+    await expect(
+      updateCategoryUseCase({ id: category.id, name: "Accessories" }),
+    ).resolves.toEqual({
+      success: false,
+      errors: { name: ["Category name is the same as the old one"] },
+    })
+
+    await expect(
+      updateCategoryUseCase({ id: category.id, name: other.name }),
+    ).resolves.toEqual({
+      success: false,
+      errors: { name: ["Category already exists"] },
+    })
+
+    await expect(
+      prisma.category.findUniqueOrThrow({ where: { id: category.id } }),
+    ).resolves.toMatchObject({ name: "Accessories" })
+  })
+
+  it("deletes empty categories and blocks deleting categories with items", async () => {
+    const categoryWithItems = await createTestCategory(prisma, {
+      name: "Computers",
+    })
+    await createTestItem(prisma, { categoryId: categoryWithItems.id })
+
+    await expect(deleteCategoryUseCase(categoryWithItems.id)).resolves.toEqual({
+      success: false,
+      errors: { id: ["Category has items"] },
+    })
+
+    await expect(
+      prisma.category.findUnique({ where: { id: categoryWithItems.id } }),
+    ).resolves.not.toBeNull()
+    await expect(prisma.item.count()).resolves.toBe(1)
+
+    const emptyCategory = await createTestCategory(prisma, { name: "Cables" })
+
+    await expect(deleteCategoryUseCase(emptyCategory.id)).resolves.toEqual({
+      success: true,
+    })
+
+    await expect(
+      prisma.category.findUnique({ where: { id: emptyCategory.id } }),
+    ).resolves.toBeNull()
+  })
+})