Dependency Injection in Go: The Simple Way to More Testable Code

package main

import (
    "fmt"
    "log"
)

// A hard-coded database connection (for demonstration)
type PostgresDB struct {
    // connection fields would go here
}

func (db *PostgresDB) GetUser(id int) (string, error) {
    // In a real app, this would query the database
    return fmt.Sprintf("user_%d", id), nil
}

// Our service that needs a database
type UserService struct {
    db *PostgresDB // A direct dependency on a concrete type
}

// The constructor creates its own dependency
func NewUserService() *UserService {
    // The problem is right here!
    // We are creating the dependency inside the service.
    // This makes it impossible to replace `PostgresDB` for tests or other environments.
    return &UserService{
        db: &PostgresDB{},
    }
}

func (s *UserService) GetUser(id int) (string, error) {
    log.Printf("Getting user %d", id)
    return s.db.GetUser(id)
}

func main() {
    userService := NewUserService()
    user, err := userService.GetUser(101)
    if err != nil {
        log.Fatalf("Failed to get user: %v", err)
    }
    fmt.Println(user)
}

// UserStorer is an interface that defines the operations we need for user data.
type UserStorer interface {
    GetUser(id int) (string, error)
}

// Logger is an interface for logging messages.
type Logger interface {
    Log(message string)
}

// UserService now depends on the interfaces, not the concrete structs.
type UserService struct {
    store  UserStorer
    logger Logger
}

// The dependencies are "injected" as arguments to the constructor.
func NewUserService(s UserStorer, l Logger) *UserService {
    return &UserService{
        store:  s,
        logger: l,
    }
}

func (s *UserService) GetUser(id int) (string, error) {
    s.logger.Log(fmt.Sprintf("Getting user %d", id))
    return s.store.GetUser(id)
}

package main

import (
    "fmt"
    "log"
)

/*
--- Interfaces (Contracts) ---
*/
type UserStorer interface {
    GetUser(id int) (string, error)
}
type Logger interface {
    Log(message string)
}

/*
--- Production (Concrete) Implementations ---
*/
// PostgresDB is our real database implementation.
type PostgresDB struct { /* ... */ }

func (db *PostgresDB) GetUser(id int) (string, error) {
    return fmt.Sprintf("user_%d from postgres", id), nil
}
func NewPostgresDB() *PostgresDB { return &PostgresDB{} }


// StandardLogger is our real logger implementation.
type StandardLogger struct{}

func (l *StandardLogger) Log(message string) {
    log.Println(message)
}
func NewStandardLogger() *StandardLogger { return &StandardLogger{} }


/*
--- Service ---
*/
// UserService depends only on interfaces.
type UserService struct {
    store  UserStorer
    logger Logger
}

func NewUserService(s UserStorer, l Logger) *UserService {
    return &UserService{store: s, logger: l}
}

func (s *UserService) GetUser(id int) (string, error) {
    s.logger.Log(fmt.Sprintf("Getting user %d", id))
    return s.store.GetUser(id)
}

/*
--- Main (Composition Root) ---
*/
func main() {
    // 1. Create our concrete dependencies for PRODUCTION.
    db := NewPostgresDB()
    logger := NewStandardLogger()

    // 2. Inject them into our service.
    userService := NewUserService(db, logger)

    // 3. Use the service.
    user, err := userService.GetUser(101)
    if err != nil {
        log.Fatalf("Failed to get user: %v", err)
    }
    fmt.Println(user) // Output: user_101 from postgres
}

package main

import (
    "testing"
    "fmt"
)

// MockUserStore is a mock implementation of UserStorer for testing.
type MockUserStore struct {
    users map[int]string
}

func (m *MockUserStore) GetUser(id int) (string, error) {
    user, ok := m.users[id]
    if !ok {
        return "", fmt.Errorf("user not found")
    }
    return user, nil
}

// MockLogger does nothing, perfect for silent testing.
type MockLogger struct {}
func (m *MockLogger) Log(message string) { /* do nothing */ }


// Test the UserService in isolation.
func TestUserService_GetUser(t *testing.T) {
    // 1. Setup our MOCK dependencies.
    mockStore := &MockUserStore{
        users: map[int]string{
            1: "Alice",
        },
    }
    mockLogger := &MockLogger{}

    // 2. Inject the mocks into our service.
    userService := NewUserService(mockStore, mockLogger)

    // 3. Run the test.
    user, err := userService.GetUser(1)
    if err != nil {
        t.Errorf("Expected no error, got %v", err)
    }

    if user != "Alice" {
        t.Errorf("Expected user 'Alice', got '%s'", user)
    }
}