Nivel inicial6 min de lectura · Publicado el

Validación de un campo booleano en Ruby on Rails

Validar un booleano en Rails: con la casilla «No» marcada, presence: true responde Activo can't be blank e inclusion la acepta En un booleano, «no» cuentarubentejera.com ¿activo?SíNopresence: trueActivo can't be blankinclusion:{ in: [true, false] }
presence: true solo cuenta los «Sí»: como false.blank? es true, da el «No» por vacío y responde «Activo can't be blank». inclusion: { in: [true, false] } acepta las dos respuestas y solo rechaza nil.

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 nil es una respuesta válida. Si el campo tiene tres estados (sí, no y «aún no ha contestado»), no obligues a elegir. Añade allow_nil: true a la validación, que entonces acepta nil, y no pongas null: false en 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 un enum.
  • 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, acceptance deja pasar nil, así que solo actúa si el formulario envía el campo.

Ejercicio de cinco minutos

  1. Añade al test un caso que asigne activo: "no" y espere false. Ejecútalo: fallará, porque Rails lo convierte en true.
  2. 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.
  3. Añade la migración con null: false, default: false y comprueba en la consola que Ajuste.new.activo vale false.

Sigue leyendo

Fuentes

  • Active Record Validations, guía oficial de Rails 8.1: explica que false.blank? es true y recomienda inclusion: [true, false] o exclusion: [nil] para validar la presencia de un booleano. También documenta acceptance y allow_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: checkbox envía "1" o "0" por defecto y check_box es 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).