stock-manager/tests/unit/i18n/admin-users-dictionary.test.ts

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",
      addLabel: "Add User",
      empty: "No users found.",
      columns: {
        name: "Name",
        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",
      firstNameLabel: "First Name",
      firstNamePlaceholder: "First name",
      lastNameLabel: "Last Name",
      lastNamePlaceholder: "Last name",
      departmentLabel: "Department",
      departmentPlaceholder: "Select a department",
      emailLabel: "Email",
      emailPlaceholder: "user@example.com",
      phoneLabel: "Phone",
      phonePlaceholder: "Phone",
      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",
      NO_USER: "No user account",
    })

    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",
      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({
      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",
      addLabel: "Agregar usuario",
      empty: "No se encontraron usuarios.",
      columns: {
        name: "Nombre",
        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",
      firstNameLabel: "Nombre",
      firstNamePlaceholder: "Nombre",
      lastNameLabel: "Apellido",
      lastNamePlaceholder: "Apellido",
      departmentLabel: "Departamento",
      departmentPlaceholder: "Selecciona un departamento",
      emailLabel: "Correo electrónico",
      emailPlaceholder: "usuario@ejemplo.com",
      phoneLabel: "Teléfono",
      phonePlaceholder: "Teléfono",
      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",
      NO_USER: "Sin cuenta de usuario",
    })

    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",
      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({
      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)
}