¿Cómo pruebas código Ruby (RSpec/Minitest)?

Question

Accepted Answer

Ruby tiene una fuerte cultura de testing, con dos frameworks principales: **RSpec** (un DSL expresivo orientado al comportamiento — muy popular) y **Minitest** (más simple, ligero, el predeterminado de Rails). Ambos te permiten escribir pruebas que verifiquen el comportamiento del código, con mocking, fixtures y aserciones ricas.

## RSpec — expresivo, orientado al comportamiento

```ruby
# RSpec uses describe/it with a readable, English-like DSL
RSpec.describe Calculator do
  describe "#add" do
    it "adds two numbers" do
      calc = Calculator.new
      expect(calc.add(2, 3)).to eq(5)        # expressive expectation
    end

it "handles negatives" do
      expect(Calculator.new.add(-1, 1)).to eq(0)
    end
  end
end
```

El DSL `describe`/`it`/`expect` de RSpec se lee casi como inglés ("expect calc.add(2,3) to eq 5"), haciendo que las pruebas sean autodocumentadas — su expresividad es la razón por la que es ampliamente apreciado.

## Características de RSpec: matchers, mocks, let

```ruby
expect(result).to eq(5)              # equality
expect(list).to include("item")       # inclusion
expect { risky }.to raise_error(ArgumentError)   # exceptions
expect(user).to be_valid              # predicate matchers (be_*)

# mocking / doubles
mailer = double("Mailer")
allow(mailer).to receive(:send).and_return(true)   # stub a method
expect(mailer).to receive(:send).once               # set an expectation

# let — lazily-evaluated, memoized test data
let(:user) { User.new(name: "Ann") }
```

RSpec proporciona **matchers** ricos (`eq`, `include`, `raise_error`, predicados `be_*`), **mocks/doubles** (reemplazando dependencias con fakes controlables para aislamiento), y `let` para datos de prueba limpios.

## Minitest — más simple, ligero

```ruby
require "minitest/autorun"
class CalculatorTest < Minitest::Test
  def test_add
    assert_equal 5, Calculator.new.add(2, 3)    # assertion-style (xUnit)
  end
end
```

Minitest usa un estilo más simple, basado en aserciones (xUnit) — más ligero y rápido, y el predeterminado de Rails.

## Testing en Rails

```text
Rails has strong testing support: model tests, controller/request tests, system tests
(full-stack, browser-driven), fixtures/factories (FactoryBot) for test data.
Ruby's culture STRONGLY values testing — TDD/BDD are widely practiced.
```

## Por qué es importante

Las pruebas son esenciales para aplicaciones confiables, y Ruby tiene una notablemente **fuerte cultura de testing** (TDD/BDD son ampliamente practicados y valorados en la comunidad Ruby), por lo que entender cómo probar código Ruby es importante tanto para la calidad del código como para ser una expectativa profesional en el desarrollo Ruby.

Conocer los dos frameworks principales importa: **RSpec** (el framework comportamental expresivo y popular cuyo DSL `describe`/`it`/`expect` se lee como inglés, haciendo que las pruebas sean autodocumentadas y legibles — su expresividad es la razón por la que es tan apreciado) y **Minitest** (el más simple, ligero y basado en aserciones, predeterminado en Rails).

Entender cómo escribir pruebas, usar **matchers** (los ricos matchers `eq`/`include`/`raise_error`/predicados de RSpec para aserciones claras), y especialmente **mocks/doubles** (reemplazando dependencias con fakes controlables para pruebas rápidas y aisladas) y helpers de datos de prueba (`let`, factories como FactoryBot) cubre el alcance práctico del testing efectivo en Ruby.

En Rails, el fuerte soporte de testing (pruebas de modelo, controlador/request, y de sistema full-stack) hace que el testing exhaustivo sea práctico.

Ya que la cultura de Ruby enfatiza fuertemente el testing (el código bien probado se espera en el trabajo Ruby profesional), y dado que las aplicaciones bien probadas atrapan regresiones y permiten refactorización confiada, entender los frameworks de testing de Ruby (especialmente el popular y expresivo RSpec y el más simple Minitest), cómo escribir buenas pruebas con matchers y mocks, y las fuertes prácticas de testing de la comunidad Ruby es conocimiento de nivel senior importante que es una expectativa profesional en el desarrollo Ruby — distinguiendo a los desarrolladores que construyen aplicaciones robustas y bien probadas (la norma Ruby) de aquellos que no lo hacen, y un tema frecuentemente relevante que refleja la cultura centrada en testing que caracteriza el desarrollo Ruby y Rails de calidad.