Managing Dependencies in TDD with Python | CodeSignal Learn

Managing Dependencies in TDD with Python | CodeSignal Learn

Introduction to Managing Dependencies in TDD

In previous lessons, we explored the fundamentals of Test-Driven Development (TDD), the Red-Green-Refactor cycle, and the setup of a testing environment. 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 abstraction in Python to manage dependencies effectively. Using simple examples, we will demonstrate how to apply the Red-Green-Refactor cycle in this context. Let’s dive in.

Understanding Dependencies and Abstraction

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. In Python, abstractions can be achieved through techniques such as using duck typing or employing abstract base classes. By programming against these abstractions, 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 through an abstract base class or duck typing, 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.

Implementing a Logger Abstraction in Python

We'll create a simple logger abstraction using Python to demonstrate dependency management. This abstraction will define a method log, which our UserManager will use: Python from abc import ABC, abstractmethod class ILogger(ABC): @abstractmethod def log(self, message: str) -> None: pass The ILogger abstraction defines a single method log that accepts a message of type str . We use the Abstract Base Class (ABC) in Python to define interfaces. The simplicity of this abstraction highlights the ease of creating test stubs or mocks to simulate logging during tests without invoking an actual logging mechanism.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Building the `UserManager` with Dependency Injection

Next, we build a UserManager class by using the ILogger abstraction. We utilize dependency injection to pass in a logger, illustrating how to maintain independence between the UserManager and any specific logging implementation. class UserManager: def __init__(self, logger: ILogger): self._logger = logger self._users = [] def add_user(self, username): self._logger.log(f'User {username} added') self._users.append(username) def get_users(self): return self._users In UserManager, the logger is injected through the constructor, which allows you to provide different implementations of ILogger — such as a fake for testing or a real logger for production.

Testing with a Fake Logger

In testing, we use several different methods to simulate dependencies without relying on complex or unavailable implementations. We'll create a FakeLogger class to test the UserManager . Here's how we do it: class FakeLogger(ILogger): def __init__(self): self.logs = [] def log(self, message: str) -> None: self.logs.append(message) def test_add_user_will_log(): fake_logger = FakeLogger() user_manager = UserManager(fake_logger) user_manager.add_user('john') assert fake_logger.logs == ['User john added']

Python

class UserManager:   
    def __init__(self, logger: ILogger):
        self._logger = logger
        self._users = []

    def add_user(self, username):
        self._logger.log(f'User {username} added')
        self._users.append(username)

    def get_users(self):
        return self._users

Python

class FakeLogger(ILogger):
    def __init__(self):
        self.logs = []

    def log(self, message: str) -> None:
        self.logs.append(message)

def test_add_user_will_log():
    fake_logger = FakeLogger()
    user_manager = UserManager(fake_logger)
    user_manager.add_user('john')
    assert fake_logger.logs == ['User john added']