Comment testez-vous du code Ruby (RSpec/Minitest) ?

Question

Accepted Answer

Ruby possède une culture de test très forte, avec deux frameworks principaux : **RSpec** (un DSL expressif et orienté comportement — très populaire) et **Minitest** (plus simple, léger, défaut de Rails). Les deux vous permettent d'écrire des tests vérifiant le comportement du code, avec mocking, fixtures et assertions riches.

## RSpec — expressif, orienté comportement

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

Le DSL `describe`/`it`/`expect` de RSpec se lit presque comme de l'anglais (« expect calc.add(2,3) to eq 5 »), rendant les tests auto-documentés — son expressivité est la raison pour laquelle il est largement apprécié.

## Fonctionnalités 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 fournit des **matchers** riches (`eq`, `include`, `raise_error`, `be_*` prédicat), des **mocks/doubles** (remplaçant les dépendances par des faux contrôlables pour l'isolation), et `let` pour des données de test propres.

## Minitest — plus simple, léger

```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 utilise un style plus simple, basé sur les assertions (xUnit) — plus léger et plus rapide, et défaut de Rails.

## Tests dans 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.
```

## Pourquoi c'est important

Les tests sont essentiels pour des applications fiables, et Ruby possède une **culture de test particulièrement forte** (TDD/BDD sont largement pratiqués et valorisés dans la communauté Ruby), donc comprendre comment tester du code Ruby est important à la fois pour la qualité du code et comme attente professionnelle dans le développement Ruby.

Connaître les deux frameworks principaux est important : **RSpec** (le framework populaire orienté comportement dont le DSL expressif `describe`/`it`/`expect` se lit comme de l'anglais, rendant les tests auto-documentés et lisibles — son expressivité est la raison pour laquelle il est très apprécié) et **Minitest** (le défaut plus simple et léger basé sur les assertions dans Rails).

Comprendre comment écrire des tests, utiliser les **matchers** (les riches matchers RSpec `eq`/`include`/`raise_error`/prédicat pour des assertions claires), et surtout les **mocks/doubles** (remplaçant les dépendances par des fakes contrôlables pour des tests rapides et isolés) et les helpers de données de test (`let`, factories comme FactoryBot) couvre la portée pratique des tests Ruby efficaces.

Dans Rails, le support de test fort (tests de modèle, contrôleur/requête et système complet) rend les tests approfondis pratiques.

Puisque la culture Ruby met fortement l'accent sur les tests (le code bien testé est attendu dans le travail professionnel Ruby), et puisque les applications bien testées détectent les régressions et permettent une refactorisation confiante, comprendre les frameworks de test de Ruby (notamment le populaire et expressif RSpec et le plus simple Minitest), comment écrire de bons tests avec matchers et mocks, et les pratiques de test fortes de la communauté Ruby est une connaissance de niveau senior importante qui est une attente professionnelle dans le développement Ruby — distinguant les développeurs qui construisent des applications robustes et bien testées (la norme Ruby) de ceux qui ne le font pas, et un sujet fréquemment pertinent reflétant la culture centrée sur les tests qui caractérise le développement de qualité en Ruby et Rails.