Cum Să Implementezi Dependency Injection — Inversarea Controlului

// Greșit: cuplare strânsă
class UserService {
    private Database database;

    public UserService() {
        this.database = new Database(); // greu de testat
    }
}

// Corect: dependințe injectate
class UserService {
    private final Database database;
    private final EmailService emailService;

    public UserService(Database database, EmailService emailService) {
        this.database = database;
        this.emailService = emailService;
    }
}

from abc import ABC, abstractmethod

class UserRepository(ABC):
    @abstractmethod
    def find_by_id(self, user_id: int):
        pass

class EmailSender(ABC):
    @abstractmethod
    def send(self, to: str, subject: str, body: str):
        pass

class UserService:
    def __init__(self, repo: UserRepository, email: EmailSender):
        self._repo = repo
        self._email = email

    def register_user(self, user_id: int, email: str):
        user = self._repo.find_by_id(user_id)
        self._email.send(email, "Bun venit", "Contul tău a fost creat")

# Simple DI container
class Container:
    def __init__(self):
        self._services = {}

    def register(self, interface, implementation):
        self._services[interface] = implementation

    def resolve(self, interface):
        return self._services[interface]()

# Configurare
container = Container()
container.register(UserRepository, DatabaseRepository)
container.register(EmailSender, SMTPEmailSender)

# Folosire
service = UserService(
    container.resolve(UserRepository),
    container.resolve(EmailSender)
)

from unittest.mock import Mock

def test_register_user():
    mock_repo = Mock()
    mock_email = Mock()
    service = UserService(mock_repo, mock_email)

    service.register_user(1, "test@example.com")

    mock_repo.find_by_id.assert_called_once_with(1)
    mock_email.send.assert_called_once()