How do you test Ruby code (RSpec/Minitest)?

Question

Accepted Answer

Ruby has a strong testing culture, with two main frameworks: **RSpec** (an expressive, behavior-driven DSL — very popular) and **Minitest** (simpler, lightweight, Rails' default). Both let you write tests verifying code behavior, with mocking, fixtures, and rich assertions.

## RSpec — expressive, 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 reads almost like English ("expect calc.add(2,3) to eq 5"), making tests self-documenting — its expressiveness is why it's widely loved.

## 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 provides rich **matchers** (`eq`, `include`, `raise_error`, predicate `be_*`), **mocks/doubles** (replacing dependencies with controllable fakes for isolation), and `let` for clean test data.

## Minitest — simpler, lightweight

```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 uses a simpler, assertion-based (xUnit) style — lighter and faster, and Rails' default.

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

## Why it matters

Testing is essential for reliable applications, and Ruby has a notably **strong testing culture** (TDD/BDD are widely practiced and valued in the Ruby community), so understanding how to test Ruby code is important both for code quality and as a professional expectation in Ruby development.

Knowing the two main frameworks matters: **RSpec** (the popular, expressive behavior-driven framework whose `describe`/`it`/`expect` DSL reads like English, making tests self-documenting and readable — its expressiveness is why it's beloved) and **Minitest** (the simpler, lightweight, assertion-based default in Rails).

Understanding how to write tests, use **matchers** (RSpec's rich `eq`/`include`/`raise_error`/predicate matchers for clear assertions), and especially **mocks/doubles** (replacing dependencies with controllable fakes for fast, isolated tests) and test-data helpers (`let`, factories like FactoryBot) covers the practical scope of testing Ruby effectively.

In Rails, strong testing support (model, controller/request, and full-stack system tests) makes thorough testing practical.

Since Ruby's culture strongly emphasizes testing (well-tested code is expected in professional Ruby work), and since well-tested applications catch regressions and enable confident refactoring, understanding Ruby's testing frameworks (especially the popular, expressive RSpec and the simpler Minitest), how to write good tests with matchers and mocks, and the strong testing practices of the Ruby community is important senior-level knowledge that's a professional expectation in Ruby development — distinguishing developers who build robust, well-tested applications (the Ruby norm) from those who don't, and a frequently-relevant topic reflecting the testing-centric culture that characterizes quality Ruby and Rails development.