Como você testa código Ruby (RSpec/Minitest)?

Question

Accepted Answer

Ruby possui uma forte cultura de testes, com dois frameworks principais: **RSpec** (uma DSL expressiva orientada por comportamento — muito popular) e **Minitest** (mais simples, leve, padrão do Rails). Ambos permitem escrever testes que verificam o comportamento do código, com mocking, fixtures e assertions ricas.

## RSpec — expressivo, orientado por comportamento

```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
```

A DSL `describe`/`it`/`expect` do RSpec lê quase como inglês ("expect calc.add(2,3) to eq 5"), tornando os testes autodocumentados — sua expressividade é o motivo pelo qual é amplamente amado.

## Recursos do 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 fornece **matchers** ricos (`eq`, `include`, `raise_error`, predicados `be_*`), **mocks/doubles** (substituindo dependências por fakes controláveis para isolamento) e `let` para dados de teste limpos.

## Minitest — mais simples, leve

```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 um estilo mais simples, baseado em assertions (xUnit) — mais leve e rápido, e padrão do Rails.

## Testes em 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 que isso importa

Testes são essenciais para aplicações confiáveis, e Ruby possui uma notavelmente **forte cultura de testes** (TDD/BDD são amplamente praticados e valorizados na comunidade Ruby), então entender como testar código Ruby é importante tanto para a qualidade do código quanto como uma expectativa profissional no desenvolvimento Ruby.

Conhecer os dois frameworks principais é importante: **RSpec** (o framework popular e expressivo orientado por comportamento cuja DSL `describe`/`it`/`expect` lê como inglês, tornando os testes autodocumentados e legíveis — sua expressividade é o motivo pelo qual é amado) e **Minitest** (o padrão mais simples, leve e baseado em assertions no Rails).

Compreender como escrever testes, usar **matchers** (os ricos matchers `eq`/`include`/`raise_error`/predicados do RSpec para assertions claras) e especialmente **mocks/doubles** (substituindo dependências por fakes controláveis para testes rápidos e isolados) e helpers de dados de teste (`let`, factories como FactoryBot) cobre o escopo prático de testes Ruby efetivos.

Em Rails, suporte robusto a testes (model, controller/request e testes full-stack de sistema) torna testes completos práticos.

Como a cultura Ruby enfatiza fortemente testes (código bem testado é esperado no trabalho Ruby profissional), e como aplicações bem testadas detectam regressões e permitem refatoração confiante, entender os frameworks de testes Ruby (especialmente o popular e expressivo RSpec e o mais simples Minitest), como escrever bons testes com matchers e mocks, e as fortes práticas de testes da comunidade Ruby é conhecimento importante de nível sênior que é uma expectativa profissional no desenvolvimento Ruby — distinguindo desenvolvedores que constroem aplicações robustas e bem testadas (a norma Ruby) daqueles que não o fazem, e um tópico frequentemente relevante refletindo a cultura centrada em testes que caracteriza desenvolvimento Ruby e Rails de qualidade.