Hoe test je Ruby-code (RSpec/Minitest)?

Question

Accepted Answer

Ruby heeft een sterke testcultuur, met twee belangrijke frameworks: **RSpec** (een expressieve, behavior-driven DSL — erg populair) en **Minitest** (eenvoudiger, lichtgewicht, de standaard van Rails). Beide stellen je in staat tests te schrijven die het gedrag van code verifiëren, met mocking, fixtures en rijke assertions.

## RSpec — expressief, behavior-driven

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

RSpec's `describe`/`it`/`expect` DSL leest bijna als Engels ("expect calc.add(2,3) to eq 5"), waardoor tests zichzelf documenteren — de expresiviteit is de reden waarom het wijd en zijd geliefd is.

## RSpec features: 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 biedt rijke **matchers** (`eq`, `include`, `raise_error`, predicaat `be_*`), **mocks/doubles** (afhankelijkheden vervangen door controleerbare fakes voor isolatie) en `let` voor schone testdata.

## Minitest — eenvoudiger, lichtgewicht

```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 gebruikt een eenvoudiger, assertion-gebaseerd (xUnit) stijl — lichter en sneller, en de standaard van Rails.

## Testing in 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.
```

## Waarom het belangrijk is

Testen is essentieel voor betrouwbare applicaties, en Ruby heeft een opmerkelijk **sterke testcultuur** (TDD/BDD worden veel beoefend en gewaardeerd in de Ruby-gemeenschap), dus het begrijpen van hoe je Ruby-code test is belangrijk voor zowel codekwaliteit als professionele verwachting in Ruby-ontwikkeling.

Kennis van de twee belangrijkste frameworks is relevant: **RSpec** (het populaire, expressieve behavior-driven framework waarvan de `describe`/`it`/`expect` DSL als Engels leest, waardoor tests zichzelf documenteren en goed leesbaar zijn — de expresiviteit is de reden waarom het geliefd is) en **Minitest** (de eenvoudiger, lichtgewichte, assertion-gebaseerde standaard in Rails).

Begrip van het schrijven van tests, het gebruik van **matchers** (RSpec's rijke `eq`/`include`/`raise_error`/predicaat matchers voor duidelijke assertions), en vooral **mocks/doubles** (afhankelijkheden vervangen door controleerbare fakes voor snelle, geïsoleerde tests) en test-datahelpers (`let`, factories zoals FactoryBot) dekt de praktische scope van effectief testen van Ruby.

In Rails maakt sterke testondersteuning (model-, controller/request- en full-stack systemtests) grondig testen praktisch.

Omdat Ruby's cultuur sterk de nadruk legt op testen (goed geteste code wordt verwacht in professioneel Ruby-werk), en omdat goed geteste applicaties regressies opvangen en zelfverzekerd refactoren mogelijk maken, het begrijpen van Ruby's testframeworks (vooral het populaire, expressieve RSpec en het eenvoudiger Minitest), hoe je goede tests met matchers en mocks schrijft, en de sterke testpraktijken van de Ruby-gemeenschap is belangrijke kennis op seniorlevel die een professionele verwachting is in Ruby-ontwikkeling — het onderscheidt ontwikkelaars die robuuste, goed geteste applicaties bouwen (de Ruby-norm) van degenen die dat niet doen, en is een frequently relevant onderwerp dat de test-centrische cultuur weerspiegelt die kwaliteit Ruby en Rails-ontwikkeling karakteriseert.