Joy of Test Driven Development(TDD) using Rspec in Ruby

Aviraj Khare — Thu, 29 May 2025 02:51:39 +0000

Joy of Test Driven Development(TDD) using Rspec in Ruby

Prerequisites

I am assuming that Ruby is already installed in your system. In this example, we will be using Ruby v3.4.4

We will be using Money example for TDD.

Setup

Create a new directory called Money.
Create Gemfile file inside the directory and add only one line: https://rubygems.org.
Run bundle add rspec to install Rspec gem. You will notice that Gemfile is modified and Gemfile.lock is created.
Create two new directories called spec and lib

Very very short introduction on TDD and Red-Green-Refactor cycle

Test Driven Development(TDD) is methodology in software engineering where tests are written first and enough code is added to make all the tests pass.

The Red-Green-Refactor cycle is a core principle of Test-Driven Development (TDD). It involves writing a test that fails (Red), implementing the minimum code to make the test pass (Green), and then improving the code's design (Refactor), while ensuring all tests continue to pass.

Adding our first test

Create file called money_spec.rb in spec directory.

Inside money_spec.rb, let's type in our first test:

require './lib/money.rb'

describe Money do
  context '#initialize' do
    it { expect(Money.new(10, "USD")).to be_a(Money) }
  end
end

Now, type the command: rspec spec/money_spec.rb

Check what's the error we are getting?

An error occurred while loading ./spec/money_spec.rb.
Failure/Error: require './lib/money.rb'

LoadError:
  cannot load such file -- ./lib/money.rb
# ./spec/money_spec.rb:1:in '<top (required)>'
No examples found.

Let's try to fix this issue and let's add a file called money.rb inside lib directory.
Now, let's try running the command rspec spec/money_spec.rb command again.

We will get yet, one more error.

An error occurred while loading ./spec/money_spec.rb.
Failure/Error:
  describe Money do
    context '#initialize' do
      it { expect(Money.new(10, "USD")).to be_a(Money) }
    end
  end

NameError:
  uninitialized constant Money
# ./spec/money_spec.rb:3:in '<top (required)>'
No examples found.

Let's try to fix this error by typing following lines of code:

class Money

end

Now, we run the test again, we will get the following error:

Failures:

  1) Money#initialize 
     Failure/Error: it { expect(Money.new(10, "USD")).to be_a(Money) }

     ArgumentError:
       wrong number of arguments (given 2, expected 0)
     # ./spec/money_spec.rb:5:in 'BasicObject#initialize'
     # ./spec/money_spec.rb:5:in 'Class#new'
     # ./spec/money_spec.rb:5:in 'block (3 levels) in <top (required)>'

Finished in 0.00216 seconds (files took 0.05146 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/money_spec.rb:5 # Money#initialize

In order to fix it, let's add following line of code:

class Money
  attr_reader :amount
  def initialize(amount)
    @amount = amount
  end
end

Finally, you can see our first test case is passed.

money rspec spec/money_spec.rb
.

Finished in 0.00243 seconds (files took 0.0397 seconds to load)
1 example, 0 failures

Adding more tests - Red phase
Now let's add more tests to our Money class. We want to test that our Money object can store amount and currency correctly. Let's update our money_spec.rb:

require './lib/money.rb'

describe Money do
  context '#initialize' do
    it { expect(Money.new(10, "USD")).to be_a(Money) }

    it 'stores the amount correctly' do
      money = Money.new(25, "USD")
      expect(money.amount).to eq(25)
    end

    it 'stores the currency correctly' do
      money = Money.new(25, "USD")
      expect(money.currency).to eq("USD")
    end
  end
end

Run the tests:

rspec spec/money_spec.rb
...

Finished in 0.00312 seconds (files took 0.04221 seconds to load)
3 examples, 0 failures

Great! All tests are passing. Now let's add functionality to compare two Money objects.
Testing equality - Red phase
Let's add a test for equality comparison:

require './lib/money.rb'

describe Money do
  context '#initialize' do
    it { expect(Money.new(10, "USD")).to be_a(Money) }

    it 'stores the amount correctly' do
      money = Money.new(25, "USD")
      expect(money.amount).to eq(25)
    end

    it 'stores the currency correctly' do
      money = Money.new(25, "USD")
      expect(money.currency).to eq("USD")
    end
  end

  context '#==' do
    it 'returns true when amount and currency are the same' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(10, "USD")
      expect(money1 == money2).to be true
    end

    it 'returns false when amounts are different' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(20, "USD")
      expect(money1 == money2).to be false
    end

    it 'returns false when currencies are different' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(10, "EUR")
      expect(money1 == money2).to be false
    end
  end
end

When we run the test, we get:

Failures:

  1) Money#== returns true when amount and currency are the same
     Failure/Error: expect(money1 == money2).to be true

       expected: true
            got: false

  2) Money#== returns false when amounts are different
     Failure/Error: expect(money1 == money2).to be false

       expected: false
            got: true

  3) Money#== returns false when currencies are different
     Failure/Error: expect(money1 == money2).to be false

       expected: false
            got: true

Finished in 0.00421 seconds (files took 0.04532 seconds to load)
6 examples, 3 failures

Making equality tests pass - Green phase
Let's implement the == method in our Money class:

class Money
  attr_reader :amount, :currency

  def initialize(amount, currency)
    @amount = amount
    @currency = currency
  end

  def ==(other)
    return false unless other.is_a?(Money)
    amount == other.amount && currency == other.currency
  end
end

Now when we run the tests:

rspec spec/money_spec.rb
......

Finished in 0.00387 seconds (files took 0.04123 seconds to load)
6 examples, 0 failures

Excellent! All tests are passing.

Adding arithmetic operations - Red phase

Let's add tests for adding two Money objects:

require './lib/money.rb'

describe Money do
  context '#initialize' do
    it { expect(Money.new(10, "USD")).to be_a(Money) }

    it 'stores the amount correctly' do
      money = Money.new(25, "USD")
      expect(money.amount).to eq(25)
    end

    it 'stores the currency correctly' do
      money = Money.new(25, "USD")
      expect(money.currency).to eq("USD")
    end
  end

  context '#==' do
    it 'returns true when amount and currency are the same' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(10, "USD")
      expect(money1 == money2).to be true
    end

    it 'returns false when amounts are different' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(20, "USD")
      expect(money1 == money2).to be false
    end

    it 'returns false when currencies are different' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(10, "EUR")
      expect(money1 == money2).to be false
    end
  end

  context '#+' do
    it 'adds two Money objects with same currency' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(20, "USD")
      result = money1 + money2
      expect(result).to eq(Money.new(30, "USD"))
    end

    it 'raises error when currencies are different' do
      money1 = Money.new(10, "USD")
      money2 = Money.new(20, "EUR")
      expect { money1 + money2 }.to raise_error(ArgumentError, "Cannot add different currencies")
    end
  end
end

Running the tests:

Failures:

  1) Money#+ adds two Money objects with same currency
     Failure/Error: result = money1 + money2

     NoMethodError:
       undefined method `+' for #<Money:0x000001234567890>

  2) Money#+ raises error when currencies are different
     Failure/Error: expect { money1 + money2 }.to raise_error(ArgumentError, "Cannot add different currencies")

     NoMethodError:
       undefined method `+' for #<Money:0x000001234567890>

Finished in 0.00456 seconds (files took 0.04234 seconds to load)
8 examples, 2 failures

Implementing addition - Green phase
Let's implement the + method:

class Money
  attr_reader :amount, :currency

  def initialize(amount, currency)
    @amount = amount
    @currency = currency
  end

  def ==(other)
    return false unless other.is_a?(Money)
    amount == other.amount && currency == other.currency
  end

  def +(other)
    raise ArgumentError, "Cannot add different currencies" unless currency == other.currency
    Money.new(amount + other.amount, currency)
  end
end

Running the tests:

rspec spec/money_spec.rb
........

Finished in 0.00445 seconds (files took 0.04567 seconds to load)
8 examples, 0 failures

Perfect! All tests are passing.

Adding subtraction - Red, Green cycle

Let's add subtraction functionality:

# Add to money_spec.rb in the context '#+' section
context '#-' do
  it 'subtracts two Money objects with same currency' do
    money1 = Money.new(30, "USD")
    money2 = Money.new(10, "USD")
    result = money1 - money2
    expect(result).to eq(Money.new(20, "USD"))
  end

  it 'raises error when currencies are different' do
    money1 = Money.new(30, "USD")
    money2 = Money.new(10, "EUR")
    expect { money1 - money2 }.to raise_error(ArgumentError, "Cannot subtract different currencies")
  end
end

Add the implementation:

class Money
  attr_reader :amount, :currency

  def initialize(amount, currency)
    @amount = amount
    @currency = currency
  end

  def ==(other)
    return false unless other.is_a?(Money)
    amount == other.amount && currency == other.currency
  end

  def +(other)
    raise ArgumentError, "Cannot add different currencies" unless currency == other.currency
    Money.new(amount + other.amount, currency)
  end

  def -(other)
    raise ArgumentError, "Cannot subtract different currencies" unless currency == other.currency
    Money.new(amount - other.amount, currency)
  end
end

Adding string representation - Red, Green cycle
Let's add a test for string representation:

context '#to_s' do
  it 'returns string representation of money' do
    money = Money.new(25, "USD")
    expect(money.to_s).to eq("$25.00 USD")
  end

  it 'handles different currencies' do
    money = Money.new(50, "EUR")
    expect(money.to_s).to eq("€50.00 EUR")
  end
end

Implementation:

rubyclass Money
  attr_reader :amount, :currency

  def initialize(amount, currency)
    @amount = amount
    @currency = currency
  end

  def ==(other)
    return false unless other.is_a?(Money)
    amount == other.amount && currency == other.currency
  end

  def +(other)
    raise ArgumentError, "Cannot add different currencies" unless currency == other.currency
    Money.new(amount + other.amount, currency)
  end

  def -(other)
    raise ArgumentError, "Cannot subtract different currencies" unless currency == other.currency
    Money.new(amount - other.amount, currency)
  end

  def to_s
    symbol = currency_symbol(currency)
    "#{symbol}#{'%.2f' % amount} #{currency}"
  end

  private

  def currency_symbol(currency)
    case currency
    when "USD"
      "$"
    when "EUR"
      "€"
    when "GBP"
      "£"
    else
      ""
    end
  end
end

Final test run
Let's run all our tests to make sure everything works:

rspec spec/money_spec.rb
............

Finished in 0.00623 seconds (files took 0.04891 seconds to load)
12 examples, 0 failures

Refactor phase
Now that all our tests are passing, let's refactor our code to make it cleaner. We can extract the currency validation into a private method:

class Money
  attr_reader :amount, :currency

  def initialize(amount, currency)
    @amount = amount
    @currency = currency
  end

  def ==(other)
    return false unless other.is_a?(Money)
    amount == other.amount && currency == other.currency
  end

  def +(other)
    validate_same_currency(other)
    Money.new(amount + other.amount, currency)
  end

  def -(other)
    validate_same_currency(other)
    Money.new(amount - other.amount, currency)
  end

  def to_s
    symbol = currency_symbol(currency)
    "#{symbol}#{'%.2f' % amount} #{currency}"
  end

  private

  def validate_same_currency(other)
    unless currency == other.currency
      raise ArgumentError, "Cannot perform operation on different currencies"
    end
  end

  def currency_symbol(currency)
    case currency
    when "USD"
      "$"
    when "EUR"
      "€"
    when "GBP"
      "£"
    else
      ""
    end
  end
end

Run the tests one final time:

rspec spec/money_spec.rb
............

Finished in 0.00589 seconds (files took 0.04723 seconds to load)
12 examples, 0 failures

Conclusion

Through this example, we've demonstrated the Red-Green-Refactor cycle of TDD using RSpec in Ruby. We started with simple tests, made them pass with minimal code, and then refactored to improve the design. This approach ensures that our code is well-tested, reliable, and maintainable.

The key benefits of TDD that we experienced:

Writing tests first helps clarify requirements
Small, incremental steps make debugging easier
Refactoring with confidence knowing tests will catch regressions
Better code design through thinking about usage first

TDD takes practice, but once you get comfortable with the rhythm, you'll find it leads to better, more reliable code.

Anyone here built their own community using dev.to codebase?

Aviraj Khare — Fri, 14 Sep 2018 19:17:32 +0000

Deploy a REST API using Serverless, Django and Python

Aviraj Khare — Mon, 13 Aug 2018 05:18:01 +0000

Deploy a REST API using Serverless, Django and Python

Scaling microservices using message queues

Aviraj Khare — Thu, 02 Aug 2018 15:38:10 +0000

How to scale Microservices with Message Queues, Spring Boot, and Kubernetes

DEV Community: Aviraj Khare

Joy of Test Driven Development(TDD) using Rspec in Ruby