Nivel inicial9 min de lectura · Publicado el

Testing en Ruby: tests con Minitest, RSpec y Test::Unit

Testing en Ruby con Minitest: la lista VehiculoTest con dos tests marcados y la salida real, 2 runs, 2 assertions, 0 failures. Minitest ya viene con Rubyrubentejera.com VehiculoTesttest_guarda_la_marcatest_describe_marca_y_color2 runs, 2 assertions, 0 failures…
Cada test es una casilla de la lista que el piloto repasa antes de despegar: no vuela el avión, pero confirma que cada pieza está en su sitio. Minitest la repasa entera y resume el resultado.

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:

  1. Preparar: crear el objeto que vas a probar.
  2. Actuar: llamar al método.
  3. 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.
  • setup se ejecuta antes de cada test, así cada uno empieza con un vehículo recién creado.
  • assert_equal recibe 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:

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 nil usando assert_equal. En Minitest 6 ya no se permite: el test falla con Use assert_nil if expecting nil. Usa assert_nil resultado.
  • Olvidar el prefijo test_. Un método llamado guarda_la_marca no se ejecuta, y Minitest no avisa: la salida dice 0 runs.
  • Usar Bundler sin declarar la gema. En un proyecto con Gemfile, bundle exec solo carga lo que aparece en él. Sin gem "minitest", falla con cannot load such file -- minitest/autorun (LoadError). Lo mismo vale para gem "test-unit" y gem "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/mock ya no viene incluido: está en la gema aparte minitest-mock.

Sigue leyendo

Fuentes

Consultadas el 9 de noviembre de 2026:

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.