Qu'est-ce qu'un décorateur?

Un décorateur est un patron de conception structurel qui permet d'ajouter dynamiquement un comportement nouveau aux objets, en les enveloppant dans des objets décorateurs spéciaux.

Principes fondamentaux:

• Composition plutôt que l'héritage. Le décorateur étend la fonctionnalité de l'objet sans changer sa classe ni utiliser l'héritage.
• Flexibilité. Permet d'ajouter ou de supprimer des responsabilités de l'objet en temps d'exécution.
• Compatibilité. Les décorateurs et les objets enveloppés ont une interface commune, ce qui permet de les utiliser de manière interchangeable.

Structure:

• Composant (Component): Interface pour les objets auxquels on peut ajouter des responsabilités dynamiquement.
• Composant concret (ConcreteComponent): Implémentation du Composant.
• Décorateur (Decorator): Classe ou interface abstraite qui étend le Composant et contient une référence à un objet Composant.
• Décorateurs concrets (Concrete Decorators): Implémentations du Décorateur qui ajoutent des comportements spécifiques.

Exemple (Python):

// Interface du composant
class Coffee:
    def get_cost(self):
        pass

    def get_description(self):
        pass

// Composant concret
class SimpleCoffee(Coffee):
    def get_cost(self):
        return 1.0

    def get_description(self):
        return "Café simple"

// Décorateur de base
class CoffeeDecorator(Coffee):
    def __init__(self, decorated_coffee):
        self._decorated_coffee = decorated_coffee

    def get_cost(self):
        return self._decorated_coffee.get_cost()

    def get_description(self):
        return self._decorated_coffee.get_description()

// Décorateur concret (Lait)
class MilkDecorator(CoffeeDecorator):
    def get_cost(self):
        return self._decorated_coffee.get_cost() + 0.5

    def get_description(self):
        return self._decorated_coffee.get_description() + ", Lait"

// Utilisation
coffee = SimpleCoffee()
print(f"{coffee.get_description()}: ${coffee.get_cost()}") # Café simple: $1.0

coffee_with_milk = MilkDecorator(coffee)
print(f"{coffee_with_milk.get_description()}: ${coffee_with_milk.get_cost()}") # Café simple, Lait: $1.5

Avantages:

• Méthode plus flexible pour étendre la fonctionnalité des objets que l'héritage.
• Évite la prolifération de sous-classes liées à l'héritage.
• Permet d'ajouter plusieurs "couches" de comportement à un seul objet.

Inconvénients:

• Peut compliquer le code en raison du grand nombre d'objets petits.
• L'ordre d'enveloppement peut être important.

Application en QA / Automatisation:

• Ajout de journalisation aux méthodes existantes sans modifier leur code source.
• Mise en œuvre de la gestion des exceptions pour des appels spécifiques.
• Ajout de temporisation ou de métriques de performance.
• Utilisation dans des bibliothèques d'automatisation de tests (par exemple, dans le pattern Page Object pour ajouter des vérifications ou des journaux lors de l'interaction avec des éléments).