In previous lessons, we've explored the fundamentals of Test Driven Development (TDD) — the Red-Green-Refactor cycle — and how to set up a testing environment using Go and the Testify library. 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 interfaces for abstraction in Go, allowing us to effectively manage dependencies. Using simple examples, we will demonstrate applying the Red-Green-Refactor cycle in this context. Let’s dive in.

Dependencies in software development refer to the components or systems on which a piece of code relies 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 interface in Go acts as a type that defines method signatures without implementations. By programming against interfaces, 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 using an interface, 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 interface called Logger to demonstrate dependency management. This interface will define a method Log, which our UserManager will use:

type Logger interface {
    Log(message string)
}

The Logger interface defines a single method Log that accepts a message of type string. This simplicity 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 struct by using the Logger interface. We utilize dependency injection by passing a logger as a parameter, illustrating how to maintain independence between the UserManager and any specific logging implementation.

type UserManager struct {
    logger Logger
    users  []string
}

func NewUserManager(logger Logger) *UserManager {
    return &UserManager{
        logger: logger,
        users:  []string{},
    }
}

func (u *UserManager) AddUser(username string) {
    u.logger.Log("User " + username + " added")
    u.users = append(u.users, username)
}

func (u *UserManager) GetUsers() []string {
    return u.users
}

In UserManager, the logger is injected through the constructor function NewUserManager. This allows providing different implementations of Logger — such as a fake for testing or a real logger for production.