In previous lessons, we've explored the fundamentals of Test Driven Development (TDD), the Red-Green-Refactor cycle, and the setup of a testing environment using C++, Google Test, and Google Mock. Now, we shift our focus to a key aspect of TDD: managing dependencies. Managing dependencies ensures that each unit of your application can be tested in isolation, which is crucial in TDD for maintaining code reliability and robustness.

In this lesson, we will examine how to use abstract classes and pure virtual functions in C++ to manage dependencies effectively. Using simple examples, we will demonstrate how to apply the Red-Green-Refactor cycle in this context. We'll use C++ with Google Test and Google Mock to provide practical context. Let's dive in.

Dependencies in software development refer to the components or systems that a piece of code relies on to function properly. In the context of testing, dependencies can complicate unit tests because they might introduce external factors that affect the test outcomes. To ensure tests are isolated and independent, we use abstractions.

An abstract class in C++ acts as a base class that defines the interface for derived classes using pure virtual functions. By programming against abstract classes, you can easily swap out implementations, making code more modular and test-friendly.

For example, consider a logger that a component uses to record actions. By abstracting the logger as an abstract class, you decouple the component from a specific logging implementation. This abstraction allows you to replace the actual logger with a mock or fake when testing, thus focusing on testing the component, not its dependencies.

We'll create a simple logger abstract class called ILogger to demonstrate dependency management. This abstract class will define a pure virtual method Log, which our UserManager will use:

The ILogger abstract class defines a pure virtual method, Log, that accepts a message of type std::string. The simplicity of this abstract class highlights the ease of creating test stubs or mocks to simulate logging during tests without invoking an actual logging mechanism.

Next, we build a UserManager class by using the ILogger abstract class. We utilize dependency injection to pass in a logger, illustrating how to maintain independence between the UserManager and any specific logging implementation.

In UserManager, the logger is injected through the constructor, which allows you to provide different implementations of ILogger — such as a mock for testing or a real logger for production.

In testing, we use Google Mock to simulate dependencies without relying on complex or unavailable implementations. We'll create a mock ILogger class to test the UserManager.

Here's how we do it:

Note that we're providing the Google Mock code here but not explaining the specific mock syntax in detail (like MOCK_METHOD and EXPECT_CALL). Don't worry - we'll cover these Google Mock features thoroughly later in the learning path.

• Red: We start by writing tests for UserManager. The first test checks if a user is added correctly, while the second test verifies that logging occurs.
• Green: Implement UserManager to pass these tests, ensuring that both the user addition and logging functionalities work as expected.
• Refactor: The current implementation is effective, although always look for opportunities to improve code readability and maintainability.

In this lesson, we covered how to manage dependencies in unit testing using abstract classes and dependency injection in C++. We explored the use of mock objects with Google Mock to isolate components during tests. Here's a recap of the key points:

• Abstract dependencies using abstract classes to facilitate test isolation.
• Implement dependency injection to pass dependencies like loggers.
• Use Google Mock to simulate dependencies in unit tests.
• Always apply the TDD cycle: Red - Write a failing test, Green - Implement minimal code to pass, Refactor - Optimize the code without changing its functionality.

In the following hands-on practice sessions, you will consolidate these concepts by applying them using TDD. Continue practicing to deepen your understanding and proficiency in TDD with C++ and effective dependency management.