aferrer/stock-manager
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: consolidate admin/users management under /people

Browse Source
This commit is contained in:
Asis ferrer
2026-06-17 09:32:26 +02:00
parent 4f370eee70
commit d6b42d78e7
31 changed files with 1928 additions and 855 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/app/admin-users/admin-users-redirect.test.ts
+91
View File
@@ -0,0 +1,91 @@
import { beforeEach, describe, expect, it, vi } from "vitest"
import { en } from "@/i18n/dictionaries/en"
import { es } from "@/i18n/dictionaries/es"
const mocks = vi.hoisted(() => ({
getI18n: vi.fn(),
getUsers: vi.fn(),
getUserProfileById: vi.fn(),
findFirst: vi.fn(),
redirect: vi.fn((url: string) => {
throw new Error(`REDIRECT:${url}`)
}),
}))
vi.mock("@/i18n/server", () => ({
getI18n: mocks.getI18n,
}))
vi.mock("@/services/user.service", () => ({
getUsers: mocks.getUsers,
getUserProfileById: mocks.getUserProfileById,
}))
vi.mock("@/lib/prisma", () => ({
prisma: {
person: {
findFirst: mocks.findFirst,
},
},
default: {
person: {
findFirst: mocks.findFirst,
},
},
}))
vi.mock("next/navigation", () => ({
redirect: mocks.redirect,
}))
describe("/admin/users routes redirect to /people", () => {
beforeEach(() => {
vi.clearAllMocks()
mocks.getI18n.mockResolvedValue({ dictionary: en, locale: "en" })
})
it("redirects /admin/users to /people", async () => {
const { default: UsersPage } = await import(
"@/app/(dashboard)/admin/users/page"
)
expect(() => UsersPage()).toThrow("REDIRECT:/people")
expect(mocks.getUsers).not.toHaveBeenCalled()
})
it("redirects /admin/users/[userId]/edit to /people/[personId]/edit when person is found", async () => {
mocks.findFirst.mockResolvedValue({ id: "person-99" })
const { default: EditUserPage } = await import(
"@/app/(dashboard)/admin/users/[userId]/edit/page"
)
await expect(
EditUserPage({ params: Promise.resolve({ userId: "user-1" }) }),
).rejects.toThrow("REDIRECT:/people/person-99/edit")
expect(mocks.getUserProfileById).not.toHaveBeenCalled()
})
it("redirects /admin/users/[userId]/edit to /people when person is not found", async () => {
mocks.findFirst.mockResolvedValue(null)
const { default: EditUserPage } = await import(
"@/app/(dashboard)/admin/users/[userId]/edit/page"
)
await expect(
EditUserPage({ params: Promise.resolve({ userId: "orphan-user" }) }),
).rejects.toThrow("REDIRECT:/people")
})
it("still honors Spanish locale when redirecting (does not require dictionary lookups)", async () => {
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
const { default: UsersPage } = await import(
"@/app/(dashboard)/admin/users/page"
)
expect(() => UsersPage()).toThrow("REDIRECT:/people")
})
})
tests/unit/app/people/edit-person-form-wiring.test.ts
+170
View File
@@ -0,0 +1,170 @@
import { createElement } from "react"
import { renderToStaticMarkup } from "react-dom/server"
import { beforeEach, describe, expect, it, vi } from "vitest"
import { en } from "@/i18n/dictionaries/en"
import { es } from "@/i18n/dictionaries/es"
import type { PersonWithUser } from "@/services/person.service"
const mocks = vi.hoisted(() => ({
getI18n: vi.fn(),
findByIdWithUser: vi.fn(),
findById: vi.fn(),
personForm: vi.fn(),
push: vi.fn(),
toastError: vi.fn(),
toastSuccess: vi.fn(),
}))
vi.mock("@/i18n/server", () => ({
getI18n: mocks.getI18n,
}))
vi.mock("@/services/person.service", () => ({
PersonService: {
findByIdWithUser: mocks.findByIdWithUser,
findById: mocks.findById,
},
}))
vi.mock("@/app/(dashboard)/people/_components/edit.person.form", () => ({
default: (props: unknown) => {
mocks.personForm(props)
return createElement("div", null, "Edit person form")
},
}))
vi.mock("next/navigation", () => ({
useRouter: () => ({ push: mocks.push }),
redirect: vi.fn(),
}))
vi.mock("@/actions/person.actions", () => ({
updatePersonUserAction: vi.fn(),
}))
vi.mock("sonner", () => ({
toast: {
error: mocks.toastError,
success: mocks.toastSuccess,
},
}))
const basePerson: PersonWithUser = {
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
department: "ENGINEERING",
email: "ada@example.test",
phone: "1234",
userId: null,
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: null,
}
const personWithUser: PersonWithUser = {
...basePerson,
id: "person-2",
userId: "user-1",
user: {
id: "user-1",
name: "Ada Lovelace",
email: "ada@example.test",
role: "ADMIN",
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
password: "hashed",
},
}
describe("edit person page wiring", () => {
beforeEach(() => {
vi.clearAllMocks()
mocks.getI18n.mockResolvedValue({ dictionary: en, locale: "en" })
})
it("loads the person without user, passes PersonWithoutUser to the edit form", async () => {
mocks.findByIdWithUser.mockResolvedValue({ ...basePerson, user: null })
const { default: PersonEditPage } = await import(
"@/app/(dashboard)/people/[personId]/edit/page"
)
renderToStaticMarkup(
await PersonEditPage({
params: Promise.resolve({ personId: "person-1" }),
}),
)
expect(mocks.findByIdWithUser).toHaveBeenCalledWith("person-1")
expect(mocks.personForm).toHaveBeenCalledWith(
expect.objectContaining({
person: expect.objectContaining({
id: "person-1",
user: null,
}),
formCopy: en.admin.users.form,
schemaCopy: {
...en.admin.users.schema,
...en.inventory.people.schema,
},
roleLabels: en.admin.users.roles,
}),
)
})
it("passes Spanish copy in es locale and passes the linked User to the form", async () => {
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
mocks.findByIdWithUser.mockResolvedValue(personWithUser)
const { default: PersonEditPage } = await import(
"@/app/(dashboard)/people/[personId]/edit/page"
)
renderToStaticMarkup(
await PersonEditPage({
params: Promise.resolve({ personId: "person-2" }),
}),
)
expect(mocks.personForm).toHaveBeenCalledWith(
expect.objectContaining({
person: expect.objectContaining({
id: "person-2",
user: expect.objectContaining({
id: "user-1",
role: "ADMIN",
isActive: true,
}),
}),
formCopy: es.admin.users.form,
roleLabels: es.admin.users.roles,
departmentCopy: es.inventory.people.departments,
fallbackCopy: expect.objectContaining({
unknownDepartment: es.inventory.people.fallback.unknownDepartment,
}),
}),
)
})
it("renders 'Person not found' in Spanish when person does not exist", async () => {
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
mocks.findByIdWithUser.mockResolvedValue(null)
const { default: PersonEditPage } = await import(
"@/app/(dashboard)/people/[personId]/edit/page"
)
const html = renderToStaticMarkup(
await PersonEditPage({
params: Promise.resolve({ personId: "missing" }),
}),
)
expect(html).toContain("Persona no encontrada")
expect(mocks.personForm).not.toHaveBeenCalled()
})
})
tests/unit/app/people/person-form-pages.test.ts
+28 -5
View File
@@ -5,8 +5,10 @@ import { es } from "@/i18n/dictionaries/es"
const mocks = vi.hoisted(() => ({
getI18n: vi.fn(),
findByIdWithUser: vi.fn(),
findById: vi.fn(),
redirect: vi.fn(),
personForm: vi.fn(),
}))
vi.mock("@/i18n/server", () => ({
@@ -15,6 +17,7 @@ vi.mock("@/i18n/server", () => ({
vi.mock("@/services/person.service", () => ({
PersonService: {
findByIdWithUser: mocks.findByIdWithUser,
findById: mocks.findById,
},
}))
@@ -29,6 +32,14 @@ vi.mock("next/navigation", () => ({
vi.mock("@/actions/person.actions", () => ({
createNewPerson: vi.fn(),
updatePerson: vi.fn(),
updatePersonUserAction: vi.fn(),
}))
vi.mock("@/app/(dashboard)/people/_components/edit.person.form", () => ({
default: (props: unknown) => {
mocks.personForm(props)
return null
},
}))
vi.mock("sonner", () => ({
@@ -44,18 +55,23 @@ describe("person pages", () => {
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
})
it("renders the edit person page with Person heading and no username", async () => {
it("renders the edit person page with Person heading and passes person to unified form", async () => {
const { default: PersonEditPage } = await import(
"@/app/(dashboard)/people/[personId]/edit/page"
)
mocks.findById.mockResolvedValue({
mocks.findByIdWithUser.mockResolvedValue({
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
phone: "1234",
department: "ENGINEERING",
userId: null,
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: null,
})
const html = renderToStaticMarkup(
@@ -65,8 +81,15 @@ describe("person pages", () => {
)
expect(html).toContain("Editar persona")
expect(html).toContain("Actualizar persona")
expect(html).not.toContain("Usuario")
expect(mocks.personForm).toHaveBeenCalledWith(
expect.objectContaining({
person: expect.objectContaining({
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
}),
}),
)
})
it("renders a Person not-found message on edit page", async () => {
@@ -74,7 +97,7 @@ describe("person pages", () => {
"@/app/(dashboard)/people/[personId]/edit/page"
)
mocks.findById.mockResolvedValue(null)
mocks.findByIdWithUser.mockResolvedValue(null)
const html = renderToStaticMarkup(
await PersonEditPage({
tests/unit/app/people/person-form-wiring.test.ts
-63
View File
@@ -1,63 +0,0 @@
import { createElement } from "react"
import { renderToStaticMarkup } from "react-dom/server"
import { beforeEach, describe, expect, it, vi } from "vitest"
import { en } from "@/i18n/dictionaries/en"
const mocks = vi.hoisted(() => ({
getI18n: vi.fn(),
findById: vi.fn(),
personForm: vi.fn(),
}))
vi.mock("@/i18n/server", () => ({
getI18n: mocks.getI18n,
}))
vi.mock("@/services/person.service", () => ({
PersonService: {
findById: mocks.findById,
},
}))
vi.mock("@/app/(dashboard)/people/_components/person.form", () => ({
default: (props: unknown) => {
mocks.personForm(props)
return createElement("div", null, "Person form")
},
}))
describe("person form schema wiring", () => {
beforeEach(() => {
vi.clearAllMocks()
})
it("passes server-resolved Person schema copy into the edit person form boundary", async () => {
mocks.getI18n.mockResolvedValue({ dictionary: en, locale: "en" })
mocks.findById.mockResolvedValue({
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
department: "ENGINEERING",
email: "ada@example.test",
phone: "1234",
})
const { default: PersonEditPage } = await import(
"@/app/(dashboard)/people/[personId]/edit/page"
)
renderToStaticMarkup(
await PersonEditPage({
params: Promise.resolve({ personId: "person-1" }),
}),
)
expect(mocks.personForm).toHaveBeenCalledWith(
expect.objectContaining({
mode: "edit",
schemaCopy: en.inventory.people.schema,
}),
)
})
})
tests/unit/app/people/person-pages.test.ts
+155 -2
View File
@@ -7,6 +7,7 @@ import { en } from "@/i18n/dictionaries/en"
const mocks = vi.hoisted(() => ({
findAllPaginated: vi.fn(),
findById: vi.fn(),
findByIdWithUser: vi.fn(),
findAllByPerson: vi.fn(),
getI18n: vi.fn(),
}))
@@ -19,6 +20,7 @@ vi.mock("@/services/person.service", () => ({
PersonService: {
findAllPaginated: mocks.findAllPaginated,
findById: mocks.findById,
findByIdWithUser: mocks.findByIdWithUser,
},
}))
@@ -62,6 +64,11 @@ describe("person pages", () => {
email: "ada@example.test",
phone: "1234",
department: "ENGINEERING",
userId: null,
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: null,
},
],
totalPages: 1,
@@ -86,6 +93,72 @@ describe("person pages", () => {
expect(html).toContain("/people/person-1/edit")
})
it("renders role and status columns for people with linked users", async () => {
const { default: PeoplePage } = await import(
"@/app/(dashboard)/people/page"
)
mocks.findAllPaginated.mockResolvedValue({
data: [
{
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
phone: "1234",
department: "ENGINEERING",
userId: "user-1",
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: {
id: "user-1",
name: "Ada Lovelace",
email: "ada@example.test",
role: "ADMIN",
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
password: "hashed",
movements: [],
assignments: [],
person: null,
},
},
{
id: "person-2",
firstName: "Bob",
lastName: "Jones",
email: "bob@example.test",
phone: null,
department: "IT",
userId: null,
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: null,
},
],
totalPages: 1,
})
const html = renderToStaticMarkup(
await PeoplePage({ searchParams: Promise.resolve({}) }),
)
// Column headers from inventory.people.list.columns
expect(html).toContain("Role")
expect(html).toContain("Status")
// Person with linked user: role label + active label
expect(html).toContain("Admin")
expect(html).toContain("Active")
// Person without user: no canonical enum leaks, just placeholder
expect(html).not.toContain(">STAFF<")
expect(html).not.toContain(">ADMIN<")
})
it("renders the person list empty state from Person copy", async () => {
const { default: PeoplePage } = await import(
"@/app/(dashboard)/people/page"
@@ -108,13 +181,18 @@ describe("person pages", () => {
"@/app/(dashboard)/people/[personId]/page"
)
mocks.findById.mockResolvedValue({
mocks.findByIdWithUser.mockResolvedValue({
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
phone: "1234",
department: "DRIVER",
userId: null,
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: null,
})
mocks.findAllByPerson.mockResolvedValue([
{
@@ -144,12 +222,87 @@ describe("person pages", () => {
expect(html).toContain("Laptop")
})
it("renders person detail User role and status when person has linked User", async () => {
const { default: PersonInfoPage } = await import(
"@/app/(dashboard)/people/[personId]/page"
)
mocks.findByIdWithUser.mockResolvedValue({
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
phone: "1234",
department: "DRIVER",
userId: "user-1",
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: {
id: "user-1",
name: "Ada Lovelace",
email: "ada@example.test",
role: "ADMIN",
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
password: "hashed",
movements: [],
assignments: [],
person: null,
},
})
mocks.findAllByPerson.mockResolvedValue([])
const html = renderToStaticMarkup(
await PersonInfoPage({
params: Promise.resolve({ personId: "person-1" }),
}),
)
expect(html).toContain("Role")
expect(html).toContain("Status")
expect(html).toContain("Admin")
expect(html).toContain("Active")
// Canonical enum value must not leak into display
expect(html).not.toContain(">ADMIN<")
})
it("renders 'No user account' placeholder for person without linked User", async () => {
const { default: PersonInfoPage } = await import(
"@/app/(dashboard)/people/[personId]/page"
)
mocks.findByIdWithUser.mockResolvedValue({
id: "person-1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
phone: "1234",
department: "DRIVER",
userId: null,
isActive: true,
createdAt: new Date("2024-01-01"),
updatedAt: new Date("2024-01-01"),
user: null,
})
mocks.findAllByPerson.mockResolvedValue([])
const html = renderToStaticMarkup(
await PersonInfoPage({
params: Promise.resolve({ personId: "person-1" }),
}),
)
expect(html).toContain("No user account")
})
it("renders person detail not-found from Person copy", async () => {
const { default: PersonInfoPage } = await import(
"@/app/(dashboard)/people/[personId]/page"
)
mocks.findById.mockResolvedValue(null)
mocks.findByIdWithUser.mockResolvedValue(null)
mocks.findAllByPerson.mockResolvedValue([])
const html = renderToStaticMarkup(
tests/unit/app/users/user-form-pages.test.ts
-227
View File
@@ -1,227 +0,0 @@
import { renderToStaticMarkup } from "react-dom/server"
import { beforeEach, describe, expect, it, vi } from "vitest"
import { en } from "@/i18n/dictionaries/en"
import { es } from "@/i18n/dictionaries/es"
const mocks = vi.hoisted(() => ({
createPersonUser: vi.fn(),
getUserProfileById: vi.fn(),
getI18n: vi.fn(),
push: vi.fn(),
toastError: vi.fn(),
toastSuccess: vi.fn(),
}))
vi.mock("@/i18n/server", () => ({
getI18n: mocks.getI18n,
}))
vi.mock("@/actions/person.actions", () => ({
createPersonUserAction: mocks.createPersonUser,
}))
vi.mock("@/actions/user.actions", () => ({
updateUserAction: vi.fn(),
resetUserPasswordAction: vi.fn(),
}))
vi.mock("@/services/person.service", () => ({
PersonService: {
findById: vi.fn(),
},
}))
vi.mock("@/services/user.service", () => ({
getUserProfileById: mocks.getUserProfileById,
}))
vi.mock("next/navigation", () => ({
useRouter: () => ({
push: mocks.push,
}),
notFound: () => {
throw new Error("NOT_FOUND")
},
}))
vi.mock("sonner", () => ({
toast: {
error: mocks.toastError,
success: mocks.toastSuccess,
},
}))
describe("new user form localization", () => {
beforeEach(() => {
vi.clearAllMocks()
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
})
it("renders new user page with localized title and unified form labels in Spanish", async () => {
const { default: NewUserPage } = await import(
"@/app/(dashboard)/people/new/page"
)
const html = renderToStaticMarkup(await NewUserPage())
// Title
expect(html).toContain("Nueva persona")
// Person field labels
expect(html).toContain("Nombre")
expect(html).toContain("Apellido")
expect(html).toContain("Departamento")
expect(html).toContain("Teléfono")
// User field labels
expect(html).toContain("Correo electrónico")
expect(html).toContain("Contraseña")
expect(html).toContain("Rol")
// Role labels (display) with canonical values
expect(html).toContain("Administrador")
expect(html).toContain("Gerente")
expect(html).toContain("Personal")
expect(html).toContain("Visor")
expect(html).toContain("Sin cuenta de usuario")
// Submit button text
expect(html).toContain("Crear usuario")
})
it("renders new user page with English unified form labels in English locale", async () => {
mocks.getI18n.mockResolvedValue({ dictionary: en, locale: "en" })
const { default: NewUserPage } = await import(
"@/app/(dashboard)/people/new/page"
)
const html = renderToStaticMarkup(await NewUserPage())
expect(html).toContain("New Person")
// Person fields
expect(html).toContain("First Name")
expect(html).toContain("Last Name")
expect(html).toContain("Department")
expect(html).toContain("Phone")
// User fields
expect(html).toContain("Email")
expect(html).toContain("Password")
expect(html).toContain("Role")
expect(html).toContain("Create User")
expect(html).toContain("Admin")
expect(html).toContain("Manager")
expect(html).toContain("Staff")
expect(html).toContain("Viewer")
expect(html).toContain("No user account")
})
it("keeps canonical role values in option value attributes including NO_USER, not localized labels", async () => {
const { default: NewUserPage } = await import(
"@/app/(dashboard)/people/new/page"
)
const html = renderToStaticMarkup(await NewUserPage())
// Canonical values must be in value attributes
expect(html).toContain('value="ADMIN"')
expect(html).toContain('value="MANAGER"')
expect(html).toContain('value="STAFF"')
expect(html).toContain('value="VIEWER"')
expect(html).toContain('value="NO_USER"')
})
})
describe("edit user form localization", () => {
beforeEach(() => {
vi.clearAllMocks()
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
mocks.getUserProfileById.mockResolvedValue({
id: "user-1",
name: "Ada Lovelace",
email: "ada@example.test",
role: "ADMIN",
isActive: true,
})
})
it("renders edit user page with localized title, form labels, and reset-password section in Spanish", async () => {
const { default: EditUserPage } = await import(
"@/app/(dashboard)/admin/users/[userId]/edit/page"
)
const html = renderToStaticMarkup(
await EditUserPage({
params: Promise.resolve({ userId: "user-1" }),
}),
)
// Title
expect(html).toContain("Editar usuario")
// Form labels
expect(html).toContain("Nombre")
expect(html).toContain("Nueva contraseña")
// Role labels with canonical values
expect(html).toContain("Administrador")
expect(html).toContain('value="ADMIN"')
// Active user checkbox label
expect(html).toContain("Usuario activo")
// Submit button
expect(html).toContain("Actualizar usuario")
// Reset password section
expect(html).toContain("Restablecer contraseña")
expect(html).toContain("Nueva contraseña")
expect(html).toContain("Mínimo 8 caracteres")
})
it("renders edit user page with English labels in English locale", async () => {
mocks.getI18n.mockResolvedValue({ dictionary: en, locale: "en" })
const { default: EditUserPage } = await import(
"@/app/(dashboard)/admin/users/[userId]/edit/page"
)
const html = renderToStaticMarkup(
await EditUserPage({
params: Promise.resolve({ userId: "user-1" }),
}),
)
expect(html).toContain("Edit User")
expect(html).toContain("Active user")
expect(html).toContain("Update User")
expect(html).toContain("Reset password")
expect(html).toContain("New password")
expect(html).toContain("Reset Password")
})
it("renders edit user form with role option values as canonical enums regardless of locale", async () => {
const { default: EditUserPage } = await import(
"@/app/(dashboard)/admin/users/[userId]/edit/page"
)
const html = renderToStaticMarkup(
await EditUserPage({
params: Promise.resolve({ userId: "user-1" }),
}),
)
// Canonical role values
expect(html).toContain('value="ADMIN"')
expect(html).toContain('value="MANAGER"')
expect(html).toContain('value="STAFF"')
expect(html).toContain('value="VIEWER"')
// Spanish labels for roles
expect(html).toContain("Administrador")
})
})
tests/unit/app/users/user-pages.test.ts
-183
View File
@@ -1,183 +0,0 @@
import { createElement } from "react"
import { renderToStaticMarkup } from "react-dom/server"
import { beforeEach, describe, expect, it, vi } from "vitest"
import { en } from "@/i18n/dictionaries/en"
import { es } from "@/i18n/dictionaries/es"
import type { getUsers as _getUsers } from "@/services/user.service"
type UserData = Awaited<ReturnType<typeof _getUsers>>["data"][number]
const mocks = vi.hoisted(() => ({
getUsers: vi.fn(),
getI18n: vi.fn(),
}))
vi.mock("@/i18n/server", () => ({
getI18n: mocks.getI18n,
}))
vi.mock("@/services/user.service", () => ({
getUsers: mocks.getUsers,
}))
vi.mock("@/components/common/pageheader", () => ({
default: ({ title, addLabel }: { title?: string; addLabel?: string }) =>
createElement(
"header",
null,
[title, addLabel].filter(Boolean).join(" | "),
),
}))
vi.mock("@/components/common/pagination", () => ({
default: ({ totalPages }: { totalPages: number }) =>
createElement("nav", { "aria-label": "Pagination" }, totalPages),
}))
describe("user pages localization", () => {
beforeEach(() => {
vi.clearAllMocks()
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
})
it("renders the user list in Spanish with localized headers, status/role labels, and unchanged user data", async () => {
const { default: UsersPage } = await import(
"@/app/(dashboard)/admin/users/page"
)
mocks.getUsers.mockResolvedValue({
data: [
{
id: "user-1",
name: "Ada Lovelace",
email: "ada@example.test",
role: "ADMIN",
isActive: true,
},
{
id: "user-2",
name: "Grace Hopper",
email: "grace@example.test",
role: "STAFF",
isActive: false,
},
],
totalPages: 1,
})
const html = renderToStaticMarkup(
await UsersPage({ searchParams: Promise.resolve({}) }),
)
// Title and add label
expect(html).toContain("Usuarios")
expect(html).toContain("Agregar usuario")
// Table headers from dictionary
expect(html).toContain("Nombre")
expect(html).toContain("Correo electrónico")
expect(html).toContain("Rol")
expect(html).toContain("Estado")
expect(html).toContain("Acciones")
// Status labels from dictionary (display-only, not canonical)
expect(html).toContain("Activo")
expect(html).toContain("Inactivo")
// Role labels from dictionary (display-only, not canonical)
expect(html).toContain("Administrador")
expect(html).toContain("Personal")
// User data is never translated
expect(html).toContain("Ada Lovelace")
expect(html).toContain("ada@example.test")
expect(html).toContain("Grace Hopper")
expect(html).toContain("grace@example.test")
// Canonical role values must NOT appear as display text
expect(html).not.toContain(">ADMIN<")
expect(html).not.toContain(">STAFF<")
})
it("renders the localized user empty state when no users exist", async () => {
const { default: UsersPage } = await import(
"@/app/(dashboard)/admin/users/page"
)
mocks.getUsers.mockResolvedValue({
data: [],
totalPages: 0,
})
const html = renderToStaticMarkup(
await UsersPage({ searchParams: Promise.resolve({}) }),
)
expect(html).toContain("No se encontraron usuarios.")
})
it("renders the user list in English with English dictionary labels", async () => {
const { default: UsersPage } = await import(
"@/app/(dashboard)/admin/users/page"
)
mocks.getI18n.mockResolvedValue({ dictionary: en, locale: "en" })
mocks.getUsers.mockResolvedValue({
data: [
{
id: "user-1",
name: "Ada Lovelace",
email: "ada@example.test",
role: "MANAGER",
isActive: true,
},
],
totalPages: 1,
})
const html = renderToStaticMarkup(
await UsersPage({ searchParams: Promise.resolve({}) }),
)
// English dictionary labels
expect(html).toContain("Users")
expect(html).toContain("Add User")
expect(html).toContain("Name")
expect(html).toContain("Email")
expect(html).toContain("Role")
expect(html).toContain("Status")
expect(html).toContain("Actions")
expect(html).toContain("Active")
expect(html).toContain("Manager")
// Canonical enum value must NOT appear as display text
expect(html).not.toContain(">MANAGER<")
})
it("renders unknown role via fallback when role is not in dictionary", async () => {
const { default: UsersPage } = await import(
"@/app/(dashboard)/admin/users/page"
)
mocks.getUsers.mockResolvedValue({
data: [
{
id: "user-1",
name: "Test User",
email: "test@example.test",
role: "UNKNOWN_ROLE",
isActive: true,
} as unknown as UserData,
],
totalPages: 1,
})
const html = renderToStaticMarkup(
await UsersPage({ searchParams: Promise.resolve({}) }),
)
// Unknown role should use fallback
expect(html).toContain("Rol desconocido")
})
})
tests/unit/app/users/user.copy.test.ts
+1
View File
@@ -52,6 +52,7 @@ describe("formatPersonDepartment helper", () => {
const fallbackCopy = {
unknownDepartment: "Departamento desconocido",
unknownStatus: "Estado desconocido",
}
it("formats known department values with localized labels", () => {