Strong params en Ruby on Rails: strong parameters y expect
Si en un controlador escribes esto, Rails se niega a ejecutarlo:
@article = Article.new(params[:article])
# ActiveModel::ForbiddenAttributesError
¿Por qué? Porque desde el navegador pueden mandarte cualquier campo, no solo los que aparecen en tu formulario.
El problema: la asignación masiva
Imagina un modelo Usuario con los atributos name, age y role, donde role puede ser user o administrator. Tu formulario de registro solo muestra el nombre y la edad.
Si aceptaras params[:usuario] entero, alguien podría añadir a mano el campo role=administrator a la petición. Se guardaría, y esa persona se convertiría en administradora del sistema. A este ataque se le llama asignación masiva (mass assignment).
Es como un formulario de inscripción en papel: tú esperas nombre y edad, pero alguien añade a boli una línea que dice «y además, soy el director». Si lo archivas sin mirar, ya lo es.
Los strong parameters son la lista de campos que tú permites. Todo lo demás se descarta.
Cómo se usan los strong parameters en Rails
Opción 1: asignar campo a campo
Funciona, pero se vuelve pesado en cuanto el modelo crece:
@article = Article.new(title: params[:article][:title],
body: params[:article][:body])
Opción 2: un método privado con los campos permitidos
Es la forma habitual. En Rails 8 se usa expect:
class ArticlesController < ApplicationController
def create
@article = Article.new(article_params)
# …
end
private
def article_params
params.expect(article: [:title, :body])
end
end
Si la petición trae article[admin]=true, ese campo se descarta y solo pasan title y body.
En Rails 7 y anteriores se escribe con require y permit, que sigue funcionando en Rails 8:
def article_params
params.require(:article).permit(:title, :body)
end
require(…).permit(…) |
expect(…) |
|
|---|---|---|
| Disponible desde | Rails 4 | Rails 8.0 |
Si falta la clave article |
Error 400 (ParameterMissing) |
Error 400 (ParameterMissing) |
Si article llega como texto en vez de como hash |
Error 500 (NoMethodError) |
Error 400 (ParameterMissing) |
La diferencia está en la última fila: si alguien manipula la petición, expect responde con un error de petición incorrecta en lugar de un fallo del servidor.
Lo que no está en la lista, no entra.
Compruébalo con un test
La lista de permitidos es una regla de seguridad, así que merece un test que diga qué debe pasar y qué no. No hace falta levantar el controlador entero: ActionController::Parameters se puede crear a mano y probar como cualquier objeto. Este test usa Minitest y solo necesita la gema actionpack, la parte de Rails que incluye los controladores. Si no tienes un proyecto de Rails a mano, instálala sola:
gem install actionpack -v 8.1.4.1
Y guarda el test en usuario_params_test.rb:
require "minitest/autorun"
require "action_controller"
# Lo mismo que hace el método privado del controlador, sin el controlador
def usuario_params(params)
params.expect(usuario: [:name, :age])
end
class UsuarioParamsTest < Minitest::Test
def test_descarta_el_rol_que_no_esta_en_la_lista
params = ActionController::Parameters.new(
usuario: { name: "Ana", age: "30", role: "administrator" }
)
permitidos = usuario_params(params)
assert_equal({ "name" => "Ana", "age" => "30" }, permitidos.to_h)
refute permitidos.key?(:role)
end
def test_sin_la_clave_usuario_es_una_peticion_incorrecta
params = ActionController::Parameters.new(name: "Ana")
assert_raises(ActionController::ParameterMissing) { usuario_params(params) }
end
end
ruby usuario_params_test.rb
2 runs, 3 assertions, 0 failures, 0 errors, 0 skips
El primer test es el ataque del formulario en papel: llega role=administrator y no pasa. Si un día alguien añade :role a la lista para «arreglar» otra pantalla, este test se pone en rojo y obliga a pensarlo dos veces. Vale igual si el cambio lo propone un asistente de IA: el test no sabe quién escribió el código, solo si cumple la regla. En una aplicación completa, el mismo método se prueba también con un test de integración del controlador, que comprueba la respuesta 400.
Errores frecuentes
Todos estos ejemplos parten de la misma petición, con un texto, una lista, un objeto anidado y una lista de objetos:
datos = { article: { title: "Hola",
tags: ["ruby", "rails"],
address: { city: "Las Palmas" },
comments: [{ body: "Bien" }, { body: "Genial" }] } }
params = ActionController::Parameters.new(datos)
1. Permitir una lista o un objeto como si fuera un campo simple. :tags solo deja pasar un valor suelto (un texto, un número…). Si llega una lista, se descarta sin avisar:
params.expect(article: [:title, :tags]).to_h
# => {"title" => "Hola"}
params.expect(article: [:title, tags: []]).to_h
# => {"title" => "Hola", "tags" => ["ruby", "rails"]}
Con el objeto anidado pasa lo mismo: :address lo descarta y address: [:city] lo deja pasar.
2. Olvidar el doble corchete en una lista de objetos con expect. Para una lista de comentarios, expect pide [[ ]]. Con un solo corchete, los comentarios desaparecen:
params.expect(article: [:title, comments: [:body]]).to_h
# => {"title" => "Hola"}
params.expect(article: [:title, comments: [[:body]]]).to_h
# => {"title" => "Hola", "comments" => [{"body" => "Bien"}, {"body" => "Genial"}]}
Es a propósito: el doble corchete dice «aquí espero una lista», y así expect rechaza un objeto suelto donde debía haber una lista. Con permit, en cambio, comments: [:body] sí acepta la lista. El doble corchete también acepta el hash con índices ({"0" => {…}, "1" => {…}}) que envían los formularios con fields_for y accepts_nested_attributes_for; con un solo corchete, expect lo deja vacío. Si migras de permit a expect, revisa estos casos uno a uno.
3. Usar permit! para salir del paso. permit! marca todo como permitido, incluido el role del ataque:
ActionController::Parameters.new(article: { title: "x", role: "administrator" })
.require(:article).permit!.to_h
# => {"title" => "x", "role" => "administrator"}
La guía oficial pide «extremo cuidado» con él (traducción nuestra), porque deja asignar todos los atributos del modelo, también los que añadas en el futuro.
4. No enterarte de que un campo se ha descartado. Si olvidas un campo en la lista, no hay error: el formulario «no guarda» y no sabes por qué. Rails puede avisarte con la opción action_on_unpermitted_parameters, que por defecto vale :log en desarrollo y en test (lo apunta en el log) y false en producción. Con :raise, lanza una excepción:
# config/environments/test.rb
config.action_controller.action_on_unpermitted_parameters = :raise
ActionController::UnpermittedParameters: found unpermitted parameter: :role
Ojo: este aviso solo salta con permit, se use con require o sin él. Con expect, el campo se descarta igual, pero sin aviso ni excepción. Es así por diseño: se planteó en la incidencia #53091 de Rails, que se cerró como «not planned» (no previsto). Se ha comprobado ejecutándolo con Rails 8.1.4.1 y en el código de actionpack, tanto en esa versión como en la rama principal de Rails, donde expect filtra sin pasar esa opción. Si dependes de :raise para detectar campos olvidados, tenlo en cuenta o cúbrelo con un test como el de arriba.
Cuándo no bastan los strong params
Los strong params responden a una sola pregunta: qué campos pueden llegar al modelo. Hay dos que no responden:
- ¿El valor es correcto? Una edad de
-5es un campo permitido, así que pasa. Comprobar los valores es trabajo de las validaciones de Active Record. - ¿Esta persona puede cambiarlo? Si un administrador sí puede cambiar el
roley un usuario normal no, no basta con una lista. Hacen falta dos métodos con listas distintas y que el controlador elija según quién hace la petición. Decidir quién puede hacer qué es la autorización, y va aparte.
Ejercicio de cinco minutos
- Copia el test de
usuario_paramsy añade un campohobbiesque llegue como lista (["leer", "correr"]). Escribe primero el test que espera recibirla y comprueba que falla. - Haz que pase cambiando solo la lista de permitidos.
- Añade una lista de direcciones (
addresses: [{ city: "…" }]) y comprueba qué pasa con uno y con dos corchetes.
Sigue leyendo
- Diferencias entre link_to, redirect_to y render en Rails, con el
createcompleto. - Active Record Validations: los strong params filtran qué campos entran; las validaciones, qué valores son correctos.
- Subir archivos en Ruby on Rails: el adjunto también se permite en los strong params.
Fuentes
- Action Controller Overview: Strong Parameters, guía oficial de Rails 8.1, y la API de
ActionController::Parameters. - Configuring Rails Applications, guía oficial de Rails 8.1:
action_on_unpermitted_parameters(:logen desarrollo y test,falseen el resto;:raiselanzaActionController::UnpermittedParameters). - El comportamiento de
expectcon el doble corchete y conaction_on_unpermitted_parametersse ha comprobado también en el código deActionController::Parametersdeactionpack8.1.4.1 y de la ramamainde Rails (actionpack/lib/action_controller/metal/strong_parameters.rb), y en la incidencia #53091 (cerrada como «not planned» el 29 de septiembre de 2024):expectno lanzaUnpermittedParameters. - Ejecutado en noviembre de 2026 con Ruby 4.0.9 y Rails 8.1.4.1: el
ForbiddenAttributesError,permityexpectdescartando un campoadmin, los errores de la tabla y un test de integración de un controlador conexpect(400 cuando falta la clave). El test deusuario_paramsy los errores frecuentes se han ejecutado el 11 de noviembre de 2026 con Ruby 4.0.9,actionpack8.1.4.1 y Minitest 6.0.0 (imagen oficialruby:4.0de Docker).