Harnessing the Power of Test Doubles and Simple Stubs in RSpec

RSpec provides a wide range of tools and techniques to help you test your code effectively, and two of the most essential ones are Test Doubles and Simple Stubs.

In this article, we'll explore what Test Doubles and Simple Stubs are and how you can leverage them in RSpec to enhance your testing prowess.

Understanding Test Doubles

Test Doubles, also known as mocks, stubs, and spies, are objects used to replace real objects or components during testing. They allow you to isolate the code you're testing and control the behaviour of dependencies. RSpec provides various types of Test Doubles:

Doubles: These are basic test doubles created using double. Doubles are suitable when you don't need to specify a specific behavior. Here's an example:

allow(obj).to receive(:method_name).and_return(return_value)

Mocks: Mocks are similar to doubles but come with built-in expectations. You can specify the expected method calls and their order using expect. This allows you to ensure that certain methods are called during your test:

expect(obj).to receive(:method_name).with(arguments).and_return(return_value)

Spies: Spies are like mocks, but they also allow the method to be called without affecting the test outcome. You can use allow with a receive expectation to create a spy:

allow(obj).to receive(:method_name).and_call_original

Using Test Doubles, you can replace external services, simulate error conditions, or verify that certain methods are invoked as expected. This isolation and control are crucial for writing reliable unit tests.

Stubs: Stubs are test doubles with predefined behaviour. They allow you to control what a method returns when it's called:

allow(obj).to receive(:method_name).and_return(return_value)

Simple Stubs for Controlling Behavior

A Simple Stub is a basic form of a test double used to override the behaviour of a method temporarily during a test. Simple Stubs are great when you want to ensure that a specific method returns a predictable value. 
When testing one object, you may find that the other objects it interacts with get in the way. For example, when testing a controller, it can be cumbersome to ensure the model is used correctly:

describe PostsController do
  describe "#index" do
    it "finds the 10 latest published posts" do
      10.times { |i| create(:post, :published, title: "published#{i}") }
      create(:post, published: false, title: "unpublished")

      get :index

      expect(assigns[:posts].map(&:title)).to match_array(%w(
        published0 published1 published2 published3 published4 published5
        published6 published7 published8 published9
      ))
    end
  end
end

In this example, the setup and verification phases become complex and hard to follow because we need to re-test the logic to find 10 published posts, even though this logic is already implemented and tested in the model layer.

We can use stubs to clean it up:

describe PostsController do
  describe "#index" do
    it "finds the 10 latest published posts" do
      posts = double("latest_published")
      allow(Post).to receive(:latest_published).and_return(posts)

      get :index

      expect(assigns[:posts]).to eq(posts)
    end
  end
end

The posts variable above is called a "stub," which is a kind of "test double."

You can create test doubles in RSpec by using the double method:

posts = double("latest_published")

This creates an object that stands in for an actual list of published posts; it's like a stunt double for your actual object. Using the double method is very similar to calling Object.new, but tests that use doubles will fail with much clearer error messages. The "latest_published" string above is simply a name which will be used in test failure messages.

You can stub out a method on any object (including a test double) by using allow:

allow(Post).to receive(:latest_published).and_return(posts)

This changes the Post class to return posts whenever latest_published is called. Stubbed methods will revert to their regular behaviour after each test runs.

This approach allows you to isolate the behaviour of the Post.latest_published method and focus your test on how the controller handles the return value. It's a clean and effective way to control the behaviour of dependencies and make your tests more predictable.

Using the double and allow methods, you can create simple stubs.

Benefits of Using Test Doubles and Simple Stubs

Now that we understand what Test Doubles and Simple Stubs are, let's explore why they are beneficial:

Isolation: Test Doubles and Simple Stubs help you isolate the code under test by replacing or controlling the behaviour of dependencies. This isolation makes your tests more predictable and reliable.

Control: You have full control over the behaviour of methods or objects during testing. This control enables you to simulate different scenarios and edge cases, making your tests comprehensive.

Focus on Behavior: Test Doubles and Simple Stubs allow you to focus on testing the specific behaviour of your code without being affected by external factors or complex dependencies.

Improved Test Speed: By avoiding real external services or dependencies, your tests can run faster, as there's no need to make actual network requests or perform time-consuming operations.


Wrapping Up
In the world of Ruby testing with RSpec, Test Doubles and Simple Stubs are invaluable tools for writing effective and reliable tests. They provide isolation, control, and the ability to focus on behaviour, all of which contribute to the quality of your tests.

Whether you're simulating external services, verifying method invocations, or controlling the return values of methods, Test Doubles and Simple Stubs in RSpec empower you to write tests that catch bugs early, facilitate refactoring, and ultimately lead to more maintainable and robust Ruby code.

So, the next time you're writing tests for your Ruby application with RSpec, remember to harness the power of Test Doubles and Simple Stubs to take your testing game to the next level!