Testing en Ruby: tests con Minitest, RSpec y Test::Unit
Un test en Ruby es un trozo de código que ejecuta otro y comprueba que el resultado es el esperado. Ruby trae de serie lo necesario para escribirlos, sin instalar nada: aquí vas a ver tu primer test a mano, después con Minitest y Test::Unit, RSpec en dos minutos y, al final, cómo pasar de escribir tests a hacer TDD.
Un test es como la lista de comprobación de un piloto antes de despegar: no vuela el avión, pero confirma en segundos que cada pieza está donde debe. Cuando cambias algo, vuelves a pasar la lista y sabes si has roto otra cosa.
Qué es un test unitario (unit test) en Ruby
Un test unitario (unit test) comprueba una pieza pequeña del programa, normalmente una clase o un método, por separado del resto. Es rápido, no necesita base de datos ni red, y cuando falla te dice exactamente qué pieza se ha roto.
Todos los tests de este artículo siguen la misma forma de tres pasos:
- Preparar: crear el objeto que vas a probar.
- Actuar: llamar al método.
- Comprobar: comparar el resultado con el esperado. A esta comprobación se le llama aserción (en inglés, assertion).
Un test a mano
La flexibilidad de Ruby hace fácil escribir una comprobación sin ninguna librería. Partimos de esta clase:
# vehiculo.rb
class Vehiculo
attr_reader :marca, :color
def initialize(marca, color)
@marca = marca
@color = color
end
def to_s
"Vehículo: #{marca}\tColor: #{color}"
end
end
Y la comprobamos con fail, que lanza un error si la condición no se cumple:
# prueba_a_mano.rb
require_relative "vehiculo"
vehiculo = Vehiculo.new("Seat", "rojo")
fail "La marca debería ser Seat" unless vehiculo.marca == "Seat"
puts "Todo bien"
ruby prueba_a_mano.rb
Todo bien
Funciona, pero cuando tienes decenas de comprobaciones se complica: el primer fallo detiene todo, no hay resumen y cada uno las organiza a su manera. Para eso existen las librerías de testing (frameworks).
Minitest: los tests que trae Ruby
Minitest viene con Ruby (es una bundled gem: se instala junto a Ruby, sin hacer nada) y es la librería de tests que usa Rails por defecto. Ruby 4.0 trae Minitest 6.
# vehiculo_test.rb
require "minitest/autorun"
require_relative "vehiculo"
class VehiculoTest < Minitest::Test
def setup
@vehiculo = Vehiculo.new("Seat", "rojo")
end
def test_guarda_la_marca
assert_equal "Seat", @vehiculo.marca
end
def test_describe_marca_y_color
assert_equal "Vehículo: Seat\tColor: rojo", @vehiculo.to_s
end
end
require "minitest/autorun"carga Minitest y ejecuta los tests al terminar de leer el fichero.- Cada método que empieza por
test_es un test. setupse ejecuta antes de cada test, así cada uno empieza con un vehículo recién creado.assert_equalrecibe primero el valor esperado y después el real.
Ejecútalo:
ruby vehiculo_test.rb
Run options: --seed 25184
# Running:
..
Finished in 0.000889s, 2250.6175 runs/s, 2250.6175 assertions/s.
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
Cada punto es un test que pasa. El orden de los tests es aleatorio (por eso aparece la semilla, --seed): así, si un test depende de que otro se ejecute antes, acabarás viéndolo fallar. El orden aleatorio no evita esas dependencias, pero las saca a la luz.
Cómo se lee un fallo
Si en vehiculo_test.rb cambias "Seat" por "Opel" en la aserción de test_guarda_la_marca, la salida te dice qué esperaba, qué obtuvo y en qué línea:
Run options: --seed 1116
# Running:
F.
Finished in 0.001065s, 1877.6557 runs/s, 1877.6557 assertions/s.
1) Failure:
VehiculoTest#test_guarda_la_marca [vehiculo_test.rb:11]:
Expected: "Opel"
Actual: "Seat"
2 runs, 2 assertions, 1 failures, 0 errors, 0 skips
La F marca el test que ha fallado. Minitest distingue dos casos:
- Failure (F): una aserción no se cumple. El código se ejecuta, pero da otro resultado.
- Error (E): el código lanza una excepción inesperada, por ejemplo porque el método no existe. Lo verás en la sección de TDD.
Ver un test fallar antes de hacerlo pasar es la base de TDD, y está explicado en qué es TDD.
Ejecutar un solo test
Cuando tienes muchos tests, puedes lanzar solo uno por su nombre:
ruby vehiculo_test.rb --include test_guarda_la_marca
Run options: --include test_guarda_la_marca --seed 62532
# Running:
.
Finished in 0.001051s, 951.1309 runs/s, 951.1309 assertions/s.
1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
--include es la opción de Minitest 6. La antigua, --name, sigue funcionando por ahora. Minitest 6 también trae un comando minitest que acepta el fichero y una línea del test (la del def o cualquiera de su interior):
minitest vehiculo_test.rb:10
Run options: -n /VehiculoTest#test_guarda_la_marca/ --seed 5864
# Running:
.
Finished in 0.001242s, 805.1847 runs/s, 805.1847 assertions/s.
1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
Test::Unit en Ruby
Test::Unit (la que se busca como «ruby test unit» o test/unit) es la otra librería que trae Ruby (también como bundled gem). El mismo test se escribe casi igual:
# test_vehiculo.rb
require "test/unit"
require_relative "vehiculo"
class TestVehiculo < Test::Unit::TestCase
def setup
@vehiculo = Vehiculo.new("Seat", "rojo")
end
def test_guarda_la_marca
assert_equal("Seat", @vehiculo.marca)
end
def test_describe_marca_y_color
assert_equal("Vehículo: Seat\tColor: rojo", @vehiculo.to_s)
end
end
ruby test_vehiculo.rb
Loaded suite test_vehiculo
Started
Finished in 0.000389179 seconds.
-------------------------------------------------------------------------------
2 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
100% passed
-------------------------------------------------------------------------------
5139.02 tests/s, 5139.02 assertions/s
Las reglas son las de Minitest: métodos que empiezan por test_, setup antes de cada test y teardown después. Para lanzar uno solo, ruby test_vehiculo.rb --name test_guarda_la_marca.
RSpec en dos minutos
RSpec es otra librería de tests habitual en Ruby, también en proyectos de Rails. No viene con Ruby y su estilo es distinto: en vez de clases y métodos, describes el comportamiento con describe (qué pruebas) e it (qué debe hacer).
1. Instálalo y prepara el proyecto:
gem install rspec
rspec --init
create .rspec
create spec/spec_helper.rb
rspec --init crea la configuración y la carpeta spec/, donde van los tests. Por convención, cada fichero termina en _spec.rb.
2. Escribe el test:
# spec/vehiculo_spec.rb
require_relative "../vehiculo"
RSpec.describe Vehiculo do
subject(:vehiculo) { Vehiculo.new("Seat", "rojo") }
it "guarda la marca" do
expect(vehiculo.marca).to eq("Seat")
end
it "describe marca y color" do
expect(vehiculo.to_s).to eq("Vehículo: Seat\tColor: rojo")
end
end
subject hace el papel de setup: define el objeto que se prueba, y RSpec lo crea de nuevo para cada it. expect(...).to eq(...) se lee casi como una frase: espera que la marca sea igual a "Seat".
3. Ejecútalo:
rspec --format documentation
Vehiculo
guarda la marca
describe marca y color
Finished in 0.00234 seconds (files took 0.10327 seconds to load)
2 examples, 0 failures
Con --format documentation, la salida se lee como una especificación de lo que hace la clase. Sin esa opción, verás puntos como en Minitest.
Si un test falla, RSpec te dice qué esperaba, qué obtuvo y cómo relanzar solo ese test:
F.
Failures:
1) Vehiculo guarda la marca
Failure/Error: expect(vehiculo.marca).to eq("Opel")
expected: "Opel"
got: "Seat"
(compared using ==)
# ./spec/vehiculo_spec.rb:7:in 'block (2 levels) in <top (required)>'
Finished in 0.01009 seconds (files took 0.09229 seconds to load)
2 examples, 1 failure
Failed examples:
rspec ./spec/vehiculo_spec.rb:6 # Vehiculo guarda la marca
Minitest, Test::Unit o RSpec: cuál elegir
Comparativa nuestra, a partir de los ejemplos de arriba:
| Minitest | Test::Unit | RSpec | |
|---|---|---|---|
| Instalación | Viene con Ruby | Viene con Ruby | gem install rspec |
| Estilo | Clases y assert_equal |
Clases y assert_equal |
describe, it y expect |
| Antes de cada test | setup |
setup |
before o subject |
| Ejecutar | ruby fichero_test.rb |
ruby test_fichero.rb |
rspec |
| En Rails | Por defecto | No | Con la gema rspec-rails |
Si empiezas, Minitest basta: no instalas nada y es lo que encontrarás en una aplicación Rails nueva. Si llegas a un proyecto que ya usa RSpec, lo aprendido se traslada casi entero: cambia la forma de escribirlo, no la idea.
Organizar los tests de un proyecto: rake test
En un proyecto real, el código va en lib/ y los tests en test/:
proyecto/
├── Rakefile
├── lib/
│ └── vehiculo.rb
└── test/
└── vehiculo_test.rb
Minitest trae una tarea de Rake que encuentra y ejecuta todos los ficheros de test/ que terminan en _test.rb o empiezan por test_, y añade lib/ a la ruta de carga, así que en los tests basta con require "vehiculo":
# Rakefile
require "minitest/test_task"
Minitest::TestTask.create
task default: :test
rake test
Run options: --seed 32308
# Running:
..
Finished in 0.000969s, 2064.7825 runs/s, 2064.7825 assertions/s.
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
Con task default: :test, basta con escribir rake. En Rails no hace falta nada de esto: se usa bin/rails test.
Del test a TDD: escribir el test primero
Hasta aquí, los tests comprueban código que ya existía. TDD (Test-Driven Development, desarrollo dirigido por tests) da la vuelta al orden: escribes primero el test de lo que quieres que haga el código, lo ves fallar y solo entonces escribes el código. El ciclo completo, rojo, verde y refactor, está en el artículo qué es TDD; aquí lo ves en Ruby con un caso pequeño.
Queremos que el vehículo cuente los kilómetros que recorre. Partimos de una versión de Vehiculo sin to_s y con los kilómetros a 0:
# vehiculo.rb
class Vehiculo
attr_reader :marca, :color, :kilometros
def initialize(marca, color)
@marca = marca
@color = color
@kilometros = 0
end
end
Y de un test que ya está en verde:
# vehiculo_test.rb
require "minitest/autorun"
require_relative "vehiculo"
class VehiculoTest < Minitest::Test
def setup
@vehiculo = Vehiculo.new("Seat", "rojo")
end
def test_empieza_con_cero_kilometros
assert_equal 0, @vehiculo.kilometros
end
end
Rojo: el test antes que el código
Escribimos, dentro de VehiculoTest y debajo del test anterior, el test de lo que todavía no existe:
def test_recorrer_suma_kilometros
@vehiculo.recorrer(120)
@vehiculo.recorrer(30)
assert_equal 150, @vehiculo.kilometros
end
ruby vehiculo_test.rb
E.
1) Error:
VehiculoTest#test_recorrer_suma_kilometros:
NoMethodError: undefined method 'recorrer' for an instance of Vehiculo
vehiculo_test.rb:15:in 'VehiculoTest#test_recorrer_suma_kilometros'
2 runs, 1 assertions, 0 failures, 1 errors, 0 skips
Falla por la razón esperada: el método recorrer no existe. Ese fallo confirma que el test comprueba algo de verdad.
Verde: el código mínimo
En Vehiculo, el método más sencillo que hace pasar el test:
def recorrer(km)
@kilometros += km
end
..
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
Refactor: limpiar con los tests en verde
Con todo en verde toca mejorar el código sin cambiar lo que hace. Aquí son tres líneas y no hay nada que limpiar, así que se pasa al siguiente requisito.
Otra vuelta: un test cada vez
Siguiente requisito: no se pueden recorrer kilómetros negativos. De nuevo, primero el test:
def test_no_acepta_kilometros_negativos
assert_raises(ArgumentError) { @vehiculo.recorrer(-5) }
end
.F.
1) Failure:
VehiculoTest#test_no_acepta_kilometros_negativos [vehiculo_test.rb:22]:
ArgumentError expected but nothing was raised.
3 runs, 3 assertions, 1 failures, 0 errors, 0 skips
Y después, el código que lo hace pasar:
def recorrer(km)
raise ArgumentError, "los kilómetros no pueden ser negativos" if km.negative?
@kilometros += km
end
...
3 runs, 3 assertions, 0 failures, 0 errors, 0 skips
(Las salidas de esta sección están recortadas: sin la semilla ni los tiempos.)
Fíjate en la diferencia con el resto del artículo: aquí el test decide qué código se escribe, y no al revés. Para seguir:
- Metodología TDD: pasos para aplicarla, con un ejemplo completo de principio a fin.
- El algoritmo TDD: las reglas de cada paso del ciclo.
Errores típicos
- Invertir el orden en
assert_equal. El primero es el valor esperado; si los cambias, el mensaje de fallo dirá lo contrario de lo que pasa. - Comparar con
nilusandoassert_equal. En Minitest 6 ya no se permite: el test falla conUse assert_nil if expecting nil.Usaassert_nil resultado. - Olvidar el prefijo
test_. Un método llamadoguarda_la_marcano se ejecuta, y Minitest no avisa: la salida dice0 runs. - Usar Bundler sin declarar la gema. En un proyecto con
Gemfile,bundle execsolo carga lo que aparece en él. Singem "minitest", falla concannot load such file -- minitest/autorun (LoadError). Lo mismo vale paragem "test-unit"ygem "rspec". - Tests que dependen unos de otros. Si un test solo pasa cuando otro se ejecuta antes, fallará de vez en cuando por el orden aleatorio. Prepara todo lo que necesita cada test en
setup. - Buscar los mocks en Minitest 6.
minitest/mockya no viene incluido: está en la gema aparteminitest-mock.
Sigue leyendo
- Qué es TDD: el ciclo completo y por qué escribir el test primero.
- Composición de un test en TDD y sus métodos:
describe,it,expecty el patrón preparar, actuar y comprobar. - Excepciones en Ruby: para entender el
raise ArgumentErrordel ejemplo. - Clases en Ruby: atributos,
attr_readereinitialize.
Fuentes
Consultadas el 9 de noviembre de 2026:
- NEWS de Ruby 4.0: Minitest 6.0.0 y Test::Unit 3.7.5 como bundled gems.
- Minitest y su historial de cambios: cambios de la versión 6 (
--include, comandominitest,assert_nil,minitest-mock). - test-unit: documentación oficial.
- RSpec y el README de rspec-core: instalación, estructura y formato
documentation. - Guía de testing de Rails (Rails 8.1.4.1): Minitest es la librería de tests por defecto.
Todos los ejemplos se han ejecutado el 9 de noviembre de 2026 con Ruby 4.0.9 (imagen oficial ruby:latest de Docker), Minitest 6.0.0, test-unit 3.7.5, Rake 13.3.1 y RSpec 3.13 (rspec-core 3.13.7). Las salidas son las reales; la semilla y los tiempos cambiarán en tu equipo.