Welcome to the second lesson in our exploration of Test Driven Development (TDD) with Ruby and RSpec. Previously, you learned about using dummies to isolate dependencies. In this lesson, we'll focus on another type of test double — stubs.

By the end of this lesson, you'll understand what stubs are and how to implement them in your tests, specifically for isolating dependencies like external services.

Test doubles help us isolate parts of our application for testing. We've previously discussed dummies; now, let's move to a slightly more useful test double: stubs. Stubs are predefined answers to method calls made during testing. They don't track how they're used, unlike more complex test doubles that we'll learn about later.

Stubs are beneficial when you're testing a function that relies on an external service or complex dependency. They let you simulate the function's output, making your tests faster and more predictable. Keep in mind, though, that stubs primarily ensure your application logic functions as intended and don't necessarily verify the correctness of external dependencies.

Stubs are used to provide consistent, predefined responses to specific method calls in tests, allowing you to control the behavior of certain dependencies without implementing their actual functionality. Unlike dummies, which are mere placeholders, stubs actively simulate responses, making them useful when you need predictable outcomes from dependencies. This predictability allows you to isolate and test your application's logic without needing to rely on the behavior of external systems, which is especially helpful when those systems may be complex or introduce variability.

Let’s apply the TDD workflow to build a WeatherAlertService using stubs.

We are building a WeatherAlertService that will get its data from a WeatherService, which receives weather data and issues alerts based on certain conditions. The WeatherAlertService will need to fetch data from an external data source, which is not feasible in a testing environment. For the tests that rely on data from the WeatherService, we can define what the WeatherData looks like.

The class is structured as follows:

In a test file named weather_alert_service_spec.rb, you can include the following test cases:

Here:

• We implement a stub, WeatherServiceStub, to simulate weather data. We add the set_weather method, which allows tests to pre-define the results from the service.
• We write our first RSpec test to check if WeatherAlertService processes weather data correctly.

If we run this test, we expect it to fail initially as WeatherAlertService is not yet implemented to handle the specified conditions.

In a file named weather_alert_service.rb, you can implement the should_send_alert method with minimal logic:

If we run the tests again, our goal is to pass the specific test scenario by implementing only the needed logic without covering more cases yet.

In this lesson, we focused on integrating stubs as a practical solution for isolating dependencies in your tests. Here's a quick recap of what we covered:

• Stubs provide predefined outputs, which help in testing functionalities that depend on external services.
• We worked through the Red-Green-Refactor cycle, emphasizing writing failing tests before developing logic and refining the implementation without changing its behavior.

Prepare to practice these concepts in the upcoming exercises, where you'll tackle various scenarios and get more comfortable with using stubs and the TDD approach. Keep experimenting with test doubles and enhancing your understanding and skill set in crafting well-tested, robust Ruby code.