feat(i18n): localize admin users backbone
This commit is contained in:
@@ -0,0 +1,306 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest"
|
||||
|
||||
import { es } from "@/i18n/dictionaries/es"
|
||||
|
||||
const mocks = vi.hoisted(() => ({
|
||||
revalidatePath: vi.fn(),
|
||||
getI18n: vi.fn(),
|
||||
requireRole: vi.fn(),
|
||||
createUserUseCase: vi.fn(),
|
||||
updateUserUseCase: vi.fn(),
|
||||
setUserActiveUseCase: vi.fn(),
|
||||
resetUserPasswordUseCase: 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/user.use-cases", () => ({
|
||||
createUserUseCase: mocks.createUserUseCase,
|
||||
updateUserUseCase: mocks.updateUserUseCase,
|
||||
setUserActiveUseCase: mocks.setUserActiveUseCase,
|
||||
resetUserPasswordUseCase: mocks.resetUserPasswordUseCase,
|
||||
}))
|
||||
|
||||
import {
|
||||
createUserAction,
|
||||
resetUserPasswordAction,
|
||||
setUserActiveAction,
|
||||
updateUserAction,
|
||||
} from "@/actions/user.actions"
|
||||
|
||||
describe("user actions localization", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
mocks.getI18n.mockResolvedValue({ dictionary: es, locale: "es" })
|
||||
mocks.requireRole.mockResolvedValue({
|
||||
user: { id: "admin-1" },
|
||||
})
|
||||
})
|
||||
|
||||
describe("createUserAction", () => {
|
||||
it("returns localized schema validation errors for invalid create input", async () => {
|
||||
const result = await createUserAction({
|
||||
username: "",
|
||||
name: "",
|
||||
email: "bad",
|
||||
password: "short",
|
||||
role: "ADMIN",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(mocks.getI18n).toHaveBeenCalledOnce()
|
||||
expect(mocks.createUserUseCase).not.toHaveBeenCalled()
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
username: [es.admin.users.schema.usernameRequired],
|
||||
name: [es.admin.users.schema.nameRequired],
|
||||
email: [es.admin.users.schema.emailInvalid],
|
||||
password: [es.admin.users.schema.passwordMinLength],
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
it("localizes mapped duplicate field errors for create failures", async () => {
|
||||
mocks.createUserUseCase.mockResolvedValue({
|
||||
success: false,
|
||||
errors: {
|
||||
username: ["Username already exists"],
|
||||
email: ["Email already exists"],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await createUserAction({
|
||||
username: "ada",
|
||||
name: "Ada",
|
||||
email: "ada@example.test",
|
||||
password: "password1",
|
||||
role: "STAFF",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
username: [es.admin.users.actions.duplicateUsername],
|
||||
email: [es.admin.users.actions.duplicateEmail],
|
||||
},
|
||||
message: es.admin.users.actions.createFailure,
|
||||
})
|
||||
})
|
||||
|
||||
it("returns a localized create success message and revalidates", async () => {
|
||||
mocks.createUserUseCase.mockResolvedValue({ success: true })
|
||||
|
||||
const result = await createUserAction({
|
||||
username: "ada",
|
||||
name: "Ada",
|
||||
email: "ada@example.test",
|
||||
password: "password1",
|
||||
role: "STAFF",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: true,
|
||||
message: es.admin.users.actions.createSuccess,
|
||||
})
|
||||
expect(mocks.revalidatePath).toHaveBeenCalledWith("/admin/users")
|
||||
})
|
||||
})
|
||||
|
||||
describe("updateUserAction", () => {
|
||||
it("returns localized schema validation errors for invalid update input", async () => {
|
||||
const result = await updateUserAction({
|
||||
id: "",
|
||||
username: "",
|
||||
name: "",
|
||||
email: "bad",
|
||||
role: "ADMIN",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(mocks.getI18n).toHaveBeenCalledOnce()
|
||||
expect(mocks.updateUserUseCase).not.toHaveBeenCalled()
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
id: [es.admin.users.schema.userIdRequired],
|
||||
username: [es.admin.users.schema.usernameRequired],
|
||||
name: [es.admin.users.schema.nameRequired],
|
||||
email: [es.admin.users.schema.emailInvalid],
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
it("localizes mapped use-case errors for update failures", async () => {
|
||||
mocks.updateUserUseCase.mockResolvedValue({
|
||||
success: false,
|
||||
errors: {
|
||||
id: [
|
||||
"Cannot remove access from the last active administrator",
|
||||
"You cannot remove your own administrator access",
|
||||
],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await updateUserAction({
|
||||
id: "user-1",
|
||||
username: "admin",
|
||||
name: "Admin",
|
||||
email: "admin@example.test",
|
||||
role: "MANAGER",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
id: [
|
||||
es.admin.users.actions.lastActiveAdmin,
|
||||
es.admin.users.actions.selfAdminAccess,
|
||||
],
|
||||
},
|
||||
message: es.admin.users.actions.updateFailure,
|
||||
})
|
||||
})
|
||||
|
||||
it("returns a localized update success message and revalidates", async () => {
|
||||
mocks.updateUserUseCase.mockResolvedValue({ success: true })
|
||||
|
||||
const result = await updateUserAction({
|
||||
id: "user-1",
|
||||
username: "admin",
|
||||
name: "Admin",
|
||||
email: "admin@example.test",
|
||||
role: "ADMIN",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: true,
|
||||
message: es.admin.users.actions.updateSuccess,
|
||||
})
|
||||
expect(mocks.revalidatePath).toHaveBeenCalledWith("/admin/users")
|
||||
})
|
||||
})
|
||||
|
||||
describe("setUserActiveAction", () => {
|
||||
it("returns localized schema validation errors for invalid input", async () => {
|
||||
const result = await setUserActiveAction({
|
||||
id: "",
|
||||
isActive: false,
|
||||
})
|
||||
|
||||
expect(mocks.getI18n).toHaveBeenCalledOnce()
|
||||
expect(mocks.setUserActiveUseCase).not.toHaveBeenCalled()
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
id: [es.admin.users.schema.userIdRequired],
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
it("localizes mapped use-case errors for toggle failures", async () => {
|
||||
mocks.setUserActiveUseCase.mockResolvedValue({
|
||||
success: false,
|
||||
errors: {
|
||||
id: ["You cannot deactivate your own user"],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await setUserActiveAction({
|
||||
id: "user-1",
|
||||
isActive: false,
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
id: [es.admin.users.actions.selfDeactivate],
|
||||
},
|
||||
message: es.admin.users.actions.toggleStatusFailure,
|
||||
})
|
||||
})
|
||||
|
||||
it("returns a localized toggle status success message and revalidates", async () => {
|
||||
mocks.setUserActiveUseCase.mockResolvedValue({ success: true })
|
||||
|
||||
const result = await setUserActiveAction({
|
||||
id: "user-1",
|
||||
isActive: false,
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: true,
|
||||
message: es.admin.users.actions.toggleStatusSuccess,
|
||||
})
|
||||
expect(mocks.revalidatePath).toHaveBeenCalledWith("/admin/users")
|
||||
})
|
||||
})
|
||||
|
||||
describe("resetUserPasswordAction", () => {
|
||||
it("returns localized schema validation errors for invalid input", async () => {
|
||||
const result = await resetUserPasswordAction({
|
||||
id: "",
|
||||
password: "short",
|
||||
})
|
||||
|
||||
expect(mocks.getI18n).toHaveBeenCalledOnce()
|
||||
expect(mocks.resetUserPasswordUseCase).not.toHaveBeenCalled()
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
id: [es.admin.users.schema.userIdRequired],
|
||||
password: [es.admin.users.schema.passwordMinLength],
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
it("localizes mapped use-case errors for reset failures", async () => {
|
||||
mocks.resetUserPasswordUseCase.mockResolvedValue({
|
||||
success: false,
|
||||
errors: { id: ["User not found"] },
|
||||
})
|
||||
|
||||
const result = await resetUserPasswordAction({
|
||||
id: "nonexistent",
|
||||
password: "newpassword1",
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: false,
|
||||
errors: {
|
||||
id: [es.admin.users.actions.notFound],
|
||||
},
|
||||
message: es.admin.users.actions.resetPasswordFailure,
|
||||
})
|
||||
})
|
||||
|
||||
it("returns a localized reset success message and revalidates", async () => {
|
||||
mocks.resetUserPasswordUseCase.mockResolvedValue({ success: true })
|
||||
|
||||
const result = await resetUserPasswordAction({
|
||||
id: "user-1",
|
||||
password: "newpassword1",
|
||||
})
|
||||
|
||||
expect(result).toEqual({
|
||||
success: true,
|
||||
message: es.admin.users.actions.resetPasswordSuccess,
|
||||
})
|
||||
expect(mocks.revalidatePath).toHaveBeenCalledWith("/admin/users")
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,45 @@
|
||||
import { describe, expect, it } from "vitest"
|
||||
|
||||
import { localizeUserFieldErrors } from "@/actions/user.messages"
|
||||
import { es } from "@/i18n/dictionaries/es"
|
||||
|
||||
const actionCopy = es.admin.users.actions
|
||||
|
||||
describe("user action message localization", () => {
|
||||
it("localizes all 6 known use-case error strings to dictionary keys", () => {
|
||||
expect(
|
||||
localizeUserFieldErrors(
|
||||
{
|
||||
username: ["Username already exists"],
|
||||
email: ["Email already exists"],
|
||||
id: [
|
||||
"User not found",
|
||||
"Cannot remove access from the last active administrator",
|
||||
"You cannot remove your own administrator access",
|
||||
"You cannot deactivate your own user",
|
||||
],
|
||||
},
|
||||
actionCopy,
|
||||
),
|
||||
).toEqual({
|
||||
username: [actionCopy.duplicateUsername],
|
||||
email: [actionCopy.duplicateEmail],
|
||||
id: [
|
||||
actionCopy.notFound,
|
||||
actionCopy.lastActiveAdmin,
|
||||
actionCopy.selfAdminAccess,
|
||||
actionCopy.selfDeactivate,
|
||||
],
|
||||
})
|
||||
})
|
||||
|
||||
it("keeps unknown messages unchanged", () => {
|
||||
expect(
|
||||
localizeUserFieldErrors({ id: ["Unexpected user issue"] }, actionCopy),
|
||||
).toEqual({ id: ["Unexpected user issue"] })
|
||||
})
|
||||
|
||||
it("returns undefined for undefined input", () => {
|
||||
expect(localizeUserFieldErrors(undefined, actionCopy)).toBeUndefined()
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,200 @@
|
||||
import { describe, expect, it } from "vitest"
|
||||
|
||||
import { dictionaries, getDictionary } from "@/i18n/dictionaries"
|
||||
|
||||
describe("admin users dictionary", () => {
|
||||
it("provides localized admin users copy for English", () => {
|
||||
const users = getDictionary("en").admin.users
|
||||
|
||||
expect(users.list).toEqual({
|
||||
title: "Users",
|
||||
empty: "No users found.",
|
||||
columns: {
|
||||
name: "Name",
|
||||
username: "Username",
|
||||
email: "Email",
|
||||
role: "Role",
|
||||
status: "Status",
|
||||
actions: "Actions",
|
||||
},
|
||||
actions: {
|
||||
edit: "Edit user",
|
||||
},
|
||||
})
|
||||
|
||||
expect(users.new).toEqual({ title: "New User" })
|
||||
expect(users.edit).toEqual({ title: "Edit User" })
|
||||
|
||||
expect(users.form).toEqual({
|
||||
nameLabel: "Name",
|
||||
namePlaceholder: "Full name",
|
||||
usernameLabel: "Username",
|
||||
usernamePlaceholder: "Username",
|
||||
emailLabel: "Email",
|
||||
emailPlaceholder: "user@example.com",
|
||||
passwordLabel: "Password",
|
||||
passwordPlaceholder: "Minimum 8 characters",
|
||||
roleLabel: "Role",
|
||||
activeLabel: "Active user",
|
||||
createSubmit: "Create User",
|
||||
updateSubmit: "Update User",
|
||||
})
|
||||
|
||||
expect(users.resetPassword).toEqual({
|
||||
title: "Reset password",
|
||||
passwordLabel: "New password",
|
||||
passwordPlaceholder: "Minimum 8 characters",
|
||||
submit: "Reset Password",
|
||||
})
|
||||
|
||||
expect(users.roles).toEqual({
|
||||
ADMIN: "Admin",
|
||||
MANAGER: "Manager",
|
||||
STAFF: "Staff",
|
||||
VIEWER: "Viewer",
|
||||
})
|
||||
|
||||
expect(users.status).toEqual({
|
||||
active: "Active",
|
||||
inactive: "Inactive",
|
||||
})
|
||||
|
||||
expect(users.actions).toEqual({
|
||||
createSuccess: "User created successfully",
|
||||
createFailure: "Failed to create user",
|
||||
updateSuccess: "User updated successfully",
|
||||
updateFailure: "Failed to update user",
|
||||
toggleStatusSuccess: "User status updated successfully",
|
||||
toggleStatusFailure: "Failed to update user status",
|
||||
resetPasswordSuccess: "Password reset successfully",
|
||||
resetPasswordFailure: "Failed to reset password",
|
||||
duplicateUsername: "Username already exists",
|
||||
duplicateEmail: "Email already exists",
|
||||
notFound: "User not found",
|
||||
lastActiveAdmin:
|
||||
"Cannot remove access from the last active administrator",
|
||||
selfAdminAccess: "You cannot remove your own administrator access",
|
||||
selfDeactivate: "You cannot deactivate your own user",
|
||||
})
|
||||
|
||||
expect(users.schema).toEqual({
|
||||
usernameRequired: "Username is required",
|
||||
nameRequired: "Name is required",
|
||||
emailInvalid: "Invalid email",
|
||||
passwordMinLength: "Password must be at least 8 characters",
|
||||
userIdRequired: "User id is required",
|
||||
})
|
||||
|
||||
expect(users.fallback).toEqual({
|
||||
unknownRole: "Unknown role",
|
||||
})
|
||||
})
|
||||
|
||||
it("provides localized admin users copy for Spanish", () => {
|
||||
const users = getDictionary("es").admin.users
|
||||
|
||||
expect(users.list).toEqual({
|
||||
title: "Usuarios",
|
||||
empty: "No se encontraron usuarios.",
|
||||
columns: {
|
||||
name: "Nombre",
|
||||
username: "Usuario",
|
||||
email: "Correo electrónico",
|
||||
role: "Rol",
|
||||
status: "Estado",
|
||||
actions: "Acciones",
|
||||
},
|
||||
actions: {
|
||||
edit: "Editar usuario",
|
||||
},
|
||||
})
|
||||
|
||||
expect(users.new).toEqual({ title: "Nuevo usuario" })
|
||||
expect(users.edit).toEqual({ title: "Editar usuario" })
|
||||
|
||||
expect(users.form).toEqual({
|
||||
nameLabel: "Nombre",
|
||||
namePlaceholder: "Nombre completo",
|
||||
usernameLabel: "Usuario",
|
||||
usernamePlaceholder: "Usuario",
|
||||
emailLabel: "Correo electrónico",
|
||||
emailPlaceholder: "usuario@ejemplo.com",
|
||||
passwordLabel: "Contraseña",
|
||||
passwordPlaceholder: "Mínimo 8 caracteres",
|
||||
roleLabel: "Rol",
|
||||
activeLabel: "Usuario activo",
|
||||
createSubmit: "Crear usuario",
|
||||
updateSubmit: "Actualizar usuario",
|
||||
})
|
||||
|
||||
expect(users.resetPassword).toEqual({
|
||||
title: "Restablecer contraseña",
|
||||
passwordLabel: "Nueva contraseña",
|
||||
passwordPlaceholder: "Mínimo 8 caracteres",
|
||||
submit: "Restablecer contraseña",
|
||||
})
|
||||
|
||||
expect(users.roles).toEqual({
|
||||
ADMIN: "Administrador",
|
||||
MANAGER: "Gerente",
|
||||
STAFF: "Personal",
|
||||
VIEWER: "Visor",
|
||||
})
|
||||
|
||||
expect(users.status).toEqual({
|
||||
active: "Activo",
|
||||
inactive: "Inactivo",
|
||||
})
|
||||
|
||||
expect(users.actions).toEqual({
|
||||
createSuccess: "Usuario creado correctamente",
|
||||
createFailure: "Error al crear el usuario",
|
||||
updateSuccess: "Usuario actualizado correctamente",
|
||||
updateFailure: "Error al actualizar el usuario",
|
||||
toggleStatusSuccess: "Estado del usuario actualizado correctamente",
|
||||
toggleStatusFailure: "Error al actualizar el estado del usuario",
|
||||
resetPasswordSuccess: "Contraseña restablecida correctamente",
|
||||
resetPasswordFailure: "Error al restablecer la contraseña",
|
||||
duplicateUsername: "El nombre de usuario ya existe",
|
||||
duplicateEmail: "El correo electrónico ya existe",
|
||||
notFound: "Usuario no encontrado",
|
||||
lastActiveAdmin:
|
||||
"No se puede eliminar el acceso del último administrador activo",
|
||||
selfAdminAccess: "No puedes eliminar tu propio acceso de administrador",
|
||||
selfDeactivate: "No puedes desactivar tu propio usuario",
|
||||
})
|
||||
|
||||
expect(users.schema).toEqual({
|
||||
usernameRequired: "El usuario es obligatorio",
|
||||
nameRequired: "El nombre es obligatorio",
|
||||
emailInvalid: "Correo electrónico no válido",
|
||||
passwordMinLength: "La contraseña debe tener al menos 8 caracteres",
|
||||
userIdRequired: "El ID de usuario es obligatorio",
|
||||
})
|
||||
|
||||
expect(users.fallback).toEqual({
|
||||
unknownRole: "Rol desconocido",
|
||||
})
|
||||
})
|
||||
|
||||
it("maintains structural parity between English and Spanish admin.users", () => {
|
||||
const enKeys = extractKeyPaths(dictionaries.en.admin.users)
|
||||
const esKeys = extractKeyPaths(dictionaries.es.admin.users)
|
||||
|
||||
expect(esKeys).toEqual(enKeys)
|
||||
})
|
||||
})
|
||||
|
||||
function extractKeyPaths(value: unknown, prefix = ""): string[] {
|
||||
if (!isPlainObject(value)) return [prefix]
|
||||
|
||||
return Object.keys(value)
|
||||
.sort()
|
||||
.flatMap((key) =>
|
||||
extractKeyPaths(value[key], prefix ? `${prefix}.${key}` : key),
|
||||
)
|
||||
}
|
||||
|
||||
function isPlainObject(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === "object" && value !== null && !Array.isArray(value)
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
import { describe, expect, it } from "vitest"
|
||||
|
||||
import {
|
||||
buildCreateUserSchema,
|
||||
buildResetUserPasswordSchema,
|
||||
buildSetUserActiveSchema,
|
||||
buildUpdateUserSchema,
|
||||
createUserSchema,
|
||||
defaultUserSchemaCopy,
|
||||
type UserSchemaCopy,
|
||||
updateUserSchema,
|
||||
} from "@/schemas/user.schema"
|
||||
|
||||
const esCopy: UserSchemaCopy = {
|
||||
usernameRequired: "El usuario es obligatorio",
|
||||
nameRequired: "El nombre es obligatorio",
|
||||
emailInvalid: "Correo electrónico no válido",
|
||||
passwordMinLength: "La contraseña debe tener al menos 8 caracteres",
|
||||
userIdRequired: "El ID de usuario es obligatorio",
|
||||
}
|
||||
|
||||
const validCreateData = {
|
||||
username: "admin",
|
||||
name: "Admin User",
|
||||
email: "admin@example.test",
|
||||
password: "password1",
|
||||
role: "ADMIN" as const,
|
||||
isActive: true,
|
||||
}
|
||||
|
||||
const validUpdateData = {
|
||||
id: "user-id",
|
||||
username: "admin",
|
||||
name: "Admin User",
|
||||
email: "admin@example.test",
|
||||
role: "ADMIN" as const,
|
||||
isActive: true,
|
||||
}
|
||||
|
||||
describe("user schema localization", () => {
|
||||
it("buildCreateUserSchema with default copy produces same validation as createUserSchema", () => {
|
||||
const result = buildCreateUserSchema(defaultUserSchemaCopy).safeParse({
|
||||
username: "",
|
||||
name: "",
|
||||
email: "bad",
|
||||
password: "short",
|
||||
role: "INVALID",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
if (!result.success) {
|
||||
const errors = result.error.flatten().fieldErrors
|
||||
expect(errors.username).toContain("Username is required")
|
||||
expect(errors.name).toContain("Name is required")
|
||||
expect(errors.email).toContain("Invalid email")
|
||||
expect(errors.password).toContain(
|
||||
"Password must be at least 8 characters",
|
||||
)
|
||||
// role error comes from z.enum, not our copy
|
||||
expect(errors.role).toBeDefined()
|
||||
}
|
||||
})
|
||||
|
||||
it("buildCreateUserSchema with Spanish copy produces Spanish error messages", () => {
|
||||
const result = buildCreateUserSchema(esCopy).safeParse({
|
||||
username: "",
|
||||
name: "",
|
||||
email: "bad",
|
||||
password: "short",
|
||||
role: "INVALID",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
if (!result.success) {
|
||||
const errors = result.error.flatten().fieldErrors
|
||||
expect(errors.username).toContain(esCopy.usernameRequired)
|
||||
expect(errors.name).toContain(esCopy.nameRequired)
|
||||
expect(errors.email).toContain(esCopy.emailInvalid)
|
||||
expect(errors.password).toContain(esCopy.passwordMinLength)
|
||||
}
|
||||
})
|
||||
|
||||
it("buildUpdateUserSchema with default copy produces same validation as updateUserSchema", () => {
|
||||
const result = buildUpdateUserSchema(defaultUserSchemaCopy).safeParse({
|
||||
id: "",
|
||||
username: "",
|
||||
name: "",
|
||||
email: "bad",
|
||||
role: "INVALID",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
if (!result.success) {
|
||||
const errors = result.error.flatten().fieldErrors
|
||||
expect(errors.id).toContain("User id is required")
|
||||
expect(errors.username).toContain("Username is required")
|
||||
expect(errors.name).toContain("Name is required")
|
||||
expect(errors.email).toContain("Invalid email")
|
||||
}
|
||||
})
|
||||
|
||||
it("buildUpdateUserSchema with Spanish copy produces Spanish error messages", () => {
|
||||
const result = buildUpdateUserSchema(esCopy).safeParse({
|
||||
id: "",
|
||||
username: "",
|
||||
name: "",
|
||||
email: "bad",
|
||||
role: "INVALID",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
if (!result.success) {
|
||||
const errors = result.error.flatten().fieldErrors
|
||||
expect(errors.id).toContain(esCopy.userIdRequired)
|
||||
expect(errors.username).toContain(esCopy.usernameRequired)
|
||||
expect(errors.name).toContain(esCopy.nameRequired)
|
||||
expect(errors.email).toContain(esCopy.emailInvalid)
|
||||
}
|
||||
})
|
||||
|
||||
it("buildSetUserActiveSchema with default copy validates id requirement", () => {
|
||||
const result = buildSetUserActiveSchema(defaultUserSchemaCopy).safeParse({
|
||||
id: "",
|
||||
isActive: true,
|
||||
})
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
if (!result.success) {
|
||||
expect(result.error.flatten().fieldErrors.id).toContain(
|
||||
"User id is required",
|
||||
)
|
||||
}
|
||||
})
|
||||
|
||||
it("buildResetUserPasswordSchema with default copy validates password and id", () => {
|
||||
const result = buildResetUserPasswordSchema(
|
||||
defaultUserSchemaCopy,
|
||||
).safeParse({
|
||||
id: "",
|
||||
password: "short",
|
||||
})
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
if (!result.success) {
|
||||
const errors = result.error.flatten().fieldErrors
|
||||
expect(errors.id).toContain("User id is required")
|
||||
expect(errors.password).toContain(
|
||||
"Password must be at least 8 characters",
|
||||
)
|
||||
}
|
||||
})
|
||||
|
||||
it("default exports match builder with default copy for valid data", () => {
|
||||
expect(createUserSchema.safeParse(validCreateData).success).toBe(true)
|
||||
expect(
|
||||
buildCreateUserSchema(defaultUserSchemaCopy).safeParse(validCreateData)
|
||||
.success,
|
||||
).toBe(true)
|
||||
|
||||
expect(updateUserSchema.safeParse(validUpdateData).success).toBe(true)
|
||||
expect(
|
||||
buildUpdateUserSchema(defaultUserSchemaCopy).safeParse(validUpdateData)
|
||||
.success,
|
||||
).toBe(true)
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user