refactor: consolidate admin/users management under /people

tests/unit/actions/person.messages.test.ts

@@ -8,6 +8,7 @@ const actionCopy = {
   updateSuccess: "Persona actualizada correctamente",
   updateFailure: "Error al actualizar la persona",
   duplicateEmail: "El correo electrónico ya existe",
+  notFound: "Persona no encontrada",
 }
 
 describe("person action message localization", () => {

tests/unit/actions/update-person-user.action.test.ts

@@ -0,0 +1,218 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import { en } from "@/i18n/dictionaries/en"
+import { es } from "@/i18n/dictionaries/es"
+
+const mocks = vi.hoisted(() => ({
+  revalidatePath: vi.fn(),
+  getI18n: vi.fn(),
+  requireRole: vi.fn(),
+  updatePersonUserUseCase: vi.fn(),
+}))
+
+vi.mock("next/cache", () => ({
+  revalidatePath: mocks.revalidatePath,
+}))
+
+vi.mock("@/i18n/server", () => ({
+  getI18n: mocks.getI18n,
+}))
+
+vi.mock("@/services/auth.service", () => ({
+  requireRole: mocks.requireRole,
+}))
+
+vi.mock("@/use-cases/person.use-cases", () => ({
+  updatePersonUserUseCase: mocks.updatePersonUserUseCase,
+}))
+
+import { updatePersonUserAction } from "@/actions/person.actions"
+
+describe("updatePersonUserAction", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
+    mocks.requireRole.mockResolvedValue({ user: { id: "admin-1" } })
+  })
+
+  describe("schema validation", () => {
+    it("rejects empty id with localized idRequired error", async () => {
+      const result = await updatePersonUserAction({
+        id: "",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "ada@example.test",
+        phone: null,
+      })
+
+      expect(result).toEqual({
+        success: false,
+        errors: {
+          id: [es.inventory.people.schema.idRequired],
+        },
+      })
+      expect(mocks.updatePersonUserUseCase).not.toHaveBeenCalled()
+    })
+
+    it("rejects invalid email with localized emailInvalid error", async () => {
+      const result = await updatePersonUserAction({
+        id: "person-1",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "not-an-email",
+        phone: null,
+      })
+
+      expect(result).toEqual({
+        success: false,
+        errors: {
+          email: [es.inventory.people.schema.emailInvalid],
+        },
+      })
+      expect(mocks.updatePersonUserUseCase).not.toHaveBeenCalled()
+    })
+
+    it("rejects short password when role is provided", async () => {
+      const result = await updatePersonUserAction({
+        id: "person-1",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "ada@example.test",
+        phone: null,
+        role: "ADMIN",
+        isActive: true,
+        password: "corta",
+      })
+
+      expect(result).toEqual({
+        success: false,
+        errors: {
+          password: [es.admin.users.schema.passwordMinLength],
+        },
+      })
+      expect(mocks.updatePersonUserUseCase).not.toHaveBeenCalled()
+    })
+
+    it("rejects NO_USER role on update", async () => {
+      const result = await updatePersonUserAction({
+        id: "person-1",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "ada@example.test",
+        phone: null,
+        role: "NO_USER" as unknown as "ADMIN",
+        isActive: true,
+      })
+
+      expect(result.success).toBe(false)
+      expect(mocks.updatePersonUserUseCase).not.toHaveBeenCalled()
+    })
+
+    it("rejects invalid role enum on update", async () => {
+      const result = await updatePersonUserAction({
+        id: "person-1",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "ada@example.test",
+        phone: null,
+        role: "SUPER_ADMIN" as unknown as "ADMIN",
+        isActive: true,
+      })
+
+      expect(result.success).toBe(false)
+      expect(mocks.updatePersonUserUseCase).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("use-case failure", () => {
+    it("localizes duplicate email errors from the use case", async () => {
+      mocks.updatePersonUserUseCase.mockResolvedValue({
+        success: false,
+        errors: { email: ["Email already exists"] },
+      })
+
+      const result = await updatePersonUserAction({
+        id: "person-1",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "duplicate@example.test",
+        phone: null,
+      })
+
+      expect(result).toEqual({
+        success: false,
+        errors: {
+          email: [es.inventory.people.actions.duplicateEmail],
+        },
+        message: es.inventory.people.actions.updateFailure,
+      })
+    })
+
+    it("localizes person-not-found error from the use case", async () => {
+      mocks.updatePersonUserUseCase.mockResolvedValue({
+        success: false,
+        errors: { id: ["Person not found"] },
+      })
+
+      const result = await updatePersonUserAction({
+        id: "missing",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "ada@example.test",
+        phone: null,
+      })
+
+      expect(result.success).toBe(false)
+      if (!result.success && result.errors) {
+        expect(result.errors.id).toBeDefined()
+      }
+    })
+  })
+
+  describe("success", () => {
+    it("returns success and revalidates /people on happy path", async () => {
+      mocks.updatePersonUserUseCase.mockResolvedValue({ success: true })
+
+      const result = await updatePersonUserAction({
+        id: "person-1",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "ada@example.test",
+        phone: null,
+      })
+
+      expect(result).toEqual({
+        success: true,
+        message: es.inventory.people.actions.updateSuccess,
+      })
+      expect(mocks.revalidatePath).toHaveBeenCalledWith("/people")
+    })
+
+    it("uses English copy in en locale", async () => {
+      mocks.getI18n.mockResolvedValue({ dictionary: en, locale: "en" })
+      mocks.updatePersonUserUseCase.mockResolvedValue({ success: true })
+
+      const result = await updatePersonUserAction({
+        id: "person-1",
+        firstName: "Ada",
+        lastName: "Lovelace",
+        department: "ENGINEERING",
+        email: "ada@example.test",
+        phone: null,
+      })
+
+      expect(result).toEqual({
+        success: true,
+        message: en.inventory.people.actions.updateSuccess,
+      })
+    })
+  })
+})