Validación de un campo booleano en Ruby on Rails
Tienes un modelo con un campo booleano, por ejemplo activo, y quieres que siempre tenga valor. Lo natural es escribir presence: true. Funciona con true, pero cuando guardas un false, Rails se queja de que el campo está vacío.
Es como un formulario en papel que da por vacía la casilla «No»: la persona respondió, pero quien lo revisa solo cuenta las casillas marcadas con «Sí».
Por qué falla presence: true
presence comprueba que el valor no esté en blanco con el método blank?. Y en Ruby on Rails, false.blank? devuelve true. Así que un false legítimo no supera la validación:
class Ajuste < ApplicationRecord
validates :activo, presence: true # no lo hagas con booleanos
end
ajuste = Ajuste.new(activo: false)
ajuste.valid? # => false
ajuste.errors.full_messages # => ["Activo can't be blank"]
Cómo validar un booleano en Rails
Cualquiera de estas dos garantiza que el campo no es nil y acepta tanto true como false:
class Ajuste < ApplicationRecord
validates :activo, inclusion: { in: [true, false] }
# o bien:
# validates :activo, exclusion: { in: [nil] }
end
Ajuste.new(activo: false).valid? # => true
Ajuste.new(activo: nil).valid? # => false
| Validación | Acepta false |
Rechaza nil |
Mensaje de error por defecto |
|---|---|---|---|
presence: true |
No | Sí | «can’t be blank» |
inclusion: { in: [true, false] } |
Sí | Sí | «is not included in the list» |
exclusion: { in: [nil] } |
Sí | Sí | «is reserved» |
Por el mensaje, inclusion suele ser la más clara para quien la lea. La guía de Rails la escribe en su forma corta, inclusion: [true, false], que se comporta igual: con las dos formas, false pasa y nil da «is not included in the list».
Compruébalo con un test
Un test deja escrito qué valores aceptas, y te avisa si alguien cambia la validación por un presence «más sencillo». Parte de un modelo con un booleano:
bin/rails generate model Ajuste activo:boolean
bin/rails db:migrate
Con la validación inclusion de arriba en app/models/ajuste.rb, escribe test/models/ajuste_test.rb:
require "test_helper"
class AjusteTest < ActiveSupport::TestCase
test "acepta true y false" do
assert Ajuste.new(activo: true).valid?
assert Ajuste.new(activo: false).valid?
end
test "rechaza nil con un mensaje claro" do
ajuste = Ajuste.new(activo: nil)
assert_not ajuste.valid?
assert_equal ["Activo is not included in the list"], ajuste.errors.full_messages
end
end
bin/rails test test/models/ajuste_test.rb
2 runs, 4 assertions, 0 failures, 0 errors, 0 skips
Ahora cambia la validación por presence: true y vuelve a ejecutarlo. Fallan los dos tests (el orden en que salen cambia de una ejecución a otra):
Failure:
AjusteTest#test_acepta_true_y_false [test/models/ajuste_test.rb:6]:
Expected false to be truthy.
Failure:
AjusteTest#test_rechaza_nil_con_un_mensaje_claro [test/models/ajuste_test.rb:13]:
--- expected
+++ actual
@@ -1 +1 @@
-["Activo is not included in the list"]
+["Activo can't be blank"]
2 runs, 4 assertions, 2 failures, 0 errors, 0 skips
La línea 6 es la del false: el test dice justo lo que explica este artículo.
Qué valor llega del formulario
Si el campo es booleano en la base de datos, Rails convierte lo que llega del formulario antes de validar. Así lo hace Rails 8.1.4.1:
| Llega | Queda como |
|---|---|
"0", "f", "false", "off" (también en mayúsculas: "F", "FALSE", "OFF") |
false |
"" (cadena vacía) |
nil |
"1", "si", "abc", " " (un espacio) |
true |
"no" |
true |
Por eso la validación solo tiene que distinguir entre true, false y nil. Pero fíjate en la última fila: "no" no está en la lista de textos que significan falso, así que acaba en true. Lo mismo pasa con las mayúsculas a medias: "FALSE" da false, pero "False" y "Off" dan true. Con la casilla que genera Rails (form.checkbox, que sigue admitiendo su nombre antiguo, check_box) no pasa, porque envía "0" o "1"; pasa cuando el valor llega de un select, de una API o de un fichero importado. Si recibes textos como "sí" y "no", conviértelos tú antes de asignarlos.
Refuérzalo en la base de datos
La validación del modelo protege lo que entra por Rails, pero no lo que se escribe directamente en la base de datos ni lo que se salta las validaciones. Si el campo debe tener siempre valor, decláralo también en la migración:
class CreateAjustes < ActiveRecord::Migration[8.1]
def change
create_table :ajustes do |t|
t.boolean :activo, null: false, default: false
t.timestamps
end
end
end
Si la tabla ya existe, cambia la columna con otra migración:
class ActivoNoNulo < ActiveRecord::Migration[8.1]
def change
change_column_default :ajustes, :activo, from: nil, to: false
change_column_null :ajustes, :activo, false
end
end
Con eso, Ajuste.new.activo vale false desde el principio. Si en la tabla ya hay filas con NULL, la migración se detiene:
StandardError: An error has occurred, this and all later migrations canceled: (StandardError)
SQLite3::ConstraintException: NOT NULL constraint failed: ajustes.activo
Pasa como cuarto argumento el valor con el que rellenar esas filas antes de aplicar la restricción:
change_column_null :ajustes, :activo, false, false
En un booleano, «no» también es una respuesta.
Errores frecuentes
1. Usar presence: true. Es el error de todo el artículo: rechaza false con «Activo can’t be blank». Lo has visto fallar en el test de arriba.
2. Validar un campo que no es booleano. Si la columna es de texto (string) en vez de boolean, Rails no convierte a true o false, sino a texto. Con una columna estado de tipo string y la misma validación:
ajuste = Ajuste.new(estado: false)
ajuste.valid?
ajuste.estado # => "f"
ajuste.errors.full_messages # => ["Estado is not included in the list"]
El false se ha guardado como el texto "f", que no es true ni false. Si el campo es un sí o un no, la columna tiene que ser boolean.
3. Confiar solo en la validación. Métodos como update_column escriben en la base de datos sin validar. Con la migración de arriba aplicada, la base de datos lo frena:
ajuste = Ajuste.create!(activo: true)
ajuste.update_column(:activo, nil)
ActiveRecord::NotNullViolation
SQLite3::ConstraintException: NOT NULL constraint failed: ajustes.activo
Sin null: false en la migración, esa línea habría guardado un NULL sin avisar.
Cuándo no usar estas validaciones
- Cuando
niles una respuesta válida. Si el campo tiene tres estados (sí, no y «aún no ha contestado»), no obligues a elegir. Añadeallow_nil: truea la validación, que entonces aceptanil, y no pongasnull: falseen la migración. Si los estados son más de tres o tienen nombre propio, un booleano se queda corto: usa un campo de texto o unenum. - Para una casilla de «Acepto las condiciones». Ahí no quieres «sí o no», quieres «sí». Usa
validates :terminos, acceptance: true, que con"0"responde «Terminos must be accepted». Ojo: por defecto,acceptancedeja pasarnil, así que solo actúa si el formulario envía el campo.
Ejercicio de cinco minutos
- Añade al test un caso que asigne
activo: "no"y esperefalse. Ejecútalo: fallará, porque Rails lo convierte entrue. - Decide qué debe pasar: o conviertes el texto antes de asignarlo, o cambias el test para dejar escrito que
"no"no es un valor válido de entrada. - Añade la migración con
null: false, default: falsey comprueba en la consola queAjuste.new.activovalefalse.
Sigue leyendo
- Active Record Validations: validadores de campos en Ruby on Rails, con el resto de validaciones.
- Migraciones en Ruby on Rails, para cambiar la columna con seguridad.
- Callbacks en Ruby on Rails, para ver qué métodos se saltan las validaciones.
Fuentes
- Active Record Validations, guía oficial de Rails 8.1: explica que
false.blank?estruey recomiendainclusion: [true, false]oexclusion: [nil]para validar la presencia de un booleano. También documentaacceptanceyallow_nil. - rails en RubyGems: 8.1.4.1, la última versión estable.
- Código fuente de Action View 8.1.4.1,
form_helper.rb:checkboxenvía"1"o"0"por defecto ycheck_boxes un alias.
Ejecutado el 12 de noviembre de 2026 en Docker con las imágenes oficiales ruby:3.4 (Ruby 3.4.12) y ruby:4.0 (Ruby 4.0.9), Rails 8.1.4.1 y SQLite, con el mismo resultado en las dos: las validaciones de la tabla y sus mensajes, la forma corta de inclusion, el test en verde y en rojo, la conversión de cada texto, la columna string, update_column contra la restricción NOT NULL, allow_nil, acceptance y la migración sobre filas con NULL (estos tres últimos, solo con Ruby 3.4.12).