Welcome to the first lesson of our course on managing test doubles. In this lesson, we will explore the concept of dependencies in software testing and introduce you to the use of test doubles, starting with "dummies," the simplest form of test double.

Dependencies are components or services that your software relies on to function, like databases, logging systems, or external APIs. However, when testing, these dependencies can introduce variability, making it hard to test your code's logic reliably. Test doubles allow you to replace these real dependencies with simpler objects that mimic their behavior. This ensures tests focus solely on your code's logic without interference from external systems. For instance, by isolating an email service’s logging component using a test double, you can test email-related functionality without generating actual log entries.

During this course, we'll discuss five kinds of test doubles:

• Dummies: These are simple placeholders used to fulfill parameter requirements. They have no logic or behavior beyond satisfying an interface or method signature.
• Stubs: These provide predefined responses to specific calls during testing, allowing you to control the behavior of certain dependencies without implementing full functionality.
• Spies: These track information about interactions with dependencies, such as method calls and arguments, enabling you to verify behaviors indirectly.
• Mocks: These are more sophisticated test doubles that are both stubs and spies. They allow you to set expectations and verify that certain interactions occur during testing.
• Fakes: These are simpler implementations of complex behavior that are useful for testing, typically with some working logic, often used to simulate a real system or component.

During this lesson, you'll learn how dummies provide a straightforward way to address dependencies by serving as simple placeholders without any logic. By the end, you'll have a foundational understanding of how to utilize dummies in your workflow, paving the way for more complex test doubles in future lessons.

Let's see dummies in action by setting up tests for an EmailService application using xUnit. Here's how you can create a EmailServiceTests.cs file with dummies:

C#
Copy to clipboard
1using Xunit;
2
3public class DummyLogger : ILogger
4{
5    public void Log(string message) {}
6}
7
8public class DummyEmailSender : IEmailSender
9{
10    public void Send(string to, string subject, string body) {}
11}
12
13public class EmailServiceTests
14{
15    private EmailService _emailService;
16
17    public EmailServiceTests()
18    {
19        _emailService = new EmailService(new DummyLogger(), new DummyEmailSender());
20    }
21
22    [Fact]
23    public void ShouldAcceptValidEmailParameters()
24    {
25        var result = _emailService.SendEmail(
26            "test@example.com",
27            "Hello",
28            "This is a test"
29        );
30
31        Assert.True(result);
32    }
33
34    // Additional tests for other cases...
35}

In this example:

• DummyLogger and DummyEmailSender act as stand-ins for real implementations. They don't have any behavior; they just satisfy the interface requirements of EmailService.
• By using dummies, you reduce complexity and ensure that the tests are focusing solely on the logic within EmailService.

This method provides an introduction to isolating dependencies with minimal effort, setting the stage for learning about more advanced test doubles like stubs, mocks, and fakes.

In the example with EmailService, DummyLogger and DummyEmailSender are dummies that help isolate the service’s functionality. Rather than implementing actual logging or email-sending behavior, they simply fulfill the ILogger and IEmailSender interfaces required by EmailService. This approach keeps the test setup lightweight and efficient, focusing solely on the email parameter validation logic. By avoiding real actions, such as logging to a file or sending emails, tests run faster and remain focused on validating the core functionality of the EmailService.

To fully understand how dummies integrate into your testing workflow, let's look at the implementation of the EmailService that the tests are targeting. Here's how you can set up the EmailService in C#:

C#
Copy to clipboard
1public interface ILogger
2{
3    void Log(string message);
4}
5
6public interface IEmailSender
7{
8    void Send(string to, string subject, string body);
9}
10
11public class EmailService
12{
13    private readonly ILogger _logger;
14    private readonly IEmailSender _emailSender;
15
16    public EmailService(ILogger logger, IEmailSender emailSender)
17    {
18        _logger = logger;
19        _emailSender = emailSender;
20    }
21
22    public bool SendEmail(string to, string subject, string body)
23    {
24        if (string.IsNullOrEmpty(to) || !to.Contains("@"))
25        {
26            return false;
27        }
28
29        if (string.IsNullOrEmpty(subject))
30        {
31            return false;
32        }
33
34        if (string.IsNullOrEmpty(body) || body.Length > 1000)
35        {
36            return false;
37        }
38
39        _logger.Log($"Sending email to {to}");
40        _emailSender.Send(to, subject, body);
41        return true;
42    }
43}

This implementation outlines a basic EmailService class, using a logger and an email sender as dependencies. The method SendEmail performs basic validation checks on the email parameters and, if they're valid, logs and sends the email using the dependencies provided. By using dummies to stand in for ILogger and IEmailSender, you can isolate this email-sending logic from the complexities of actual logging and email-sending functionalities, ensuring a focused test environment.

In this lesson, you were introduced to the concept of dependencies in testing and how test doubles, specifically dummies, can help isolate these dependencies. Dummies serve as simple placeholders without behavior, allowing you to concentrate on testing the core logic of your application without external complexities. By using dummies, you can simplify test setups and focus more effectively on the behavior of the code under test. This foundational understanding sets the stage for exploring more advanced test doubles in future lessons.