Où peut-on appliquer le modèle de conception…

Dans les tests automatisés, Singleton est souvent utilisé pour gérer des ressources qui doivent être des instances uniques tout au long de la session de test.

Exemples d'utilisation :

Gestion de WebDriver : Pour garantir une seule instance de l'objet WebDriver, utilisée par toutes les classes de test. Cela évite de rouvrir/fermer le navigateur à plusieurs reprises et conserve l'état entre les étapes du test.

public class WebDriverSingleton {
    private static WebDriver instance;

    private WebDriverSingleton() {
        // Constructeur privé pour empêcher la création d'instances
    }

    public static WebDriver getInstance() {
        if (instance == null) {
            // Initialisation de WebDriver (par exemple, Chrome, Firefox)
            instance = new ChromeDriver();
        }
        return instance;
    }

    public static void quitDriver() {
        if (instance != null) {
            instance.quit();
            instance = null;
        }
    }
}

// Utilisation dans la classe de test
public class MyTests {
    @BeforeClass
    public void setup() {
        WebDriver driver = WebDriverSingleton.getInstance();
        // Utilisation de driver
    }

    @AfterClass
    public void tearDown() {
        WebDriverSingleton.quitDriver();
    }
    // Méthodes de test
}

Gestion de la connexion à la base de données : Garantie qu'il n'y a qu'une seule connexion active à la base de données pour effectuer des préconditions de test ou des vérifications de données.

public class DatabaseConnection {
    private static Connection instance;

    private DatabaseConnection() {
        // Constructeur privé
    }

    public static Connection getInstance() {
        if (instance == null) {
            try {
                // Établir la connexion à la base de données
                instance = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "user", "password");
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return instance;
    }

    public static void closeConnection() {
        if (instance != null) {
            try {
                instance.close();
                instance = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

Gestion du fichier de configuration : Chargement des paramètres de configuration à partir d'un fichier au début de l'exécution du test et fourniture d'un accès unique à ceux-ci.

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ConfigurationManager {
    private static ConfigurationManager instance;
    private Properties properties;

    private ConfigurationManager() {
        properties = new Properties();
        try (InputStream input = getClass().getClassLoader().getResourceAsStream("config.properties")) {
            if (input == null) {
                System.out.println("Désolé, impossible de trouver config.properties");
                return;
            }
            properties.load(input);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static ConfigurationManager getInstance() {
        if (instance == null) {
            instance = new ConfigurationManager();
        }
        return instance;
    }

    public String getProperty(String key) {
        return properties.getProperty(key);
    }
}

Gestion de la journalisation : Un seul instance du journal pour la gestion centralisée des logs du test.

L'utilisation de Singleton aide à gérer des ressources nécessitant une unicité, mais il faut faire attention à son utilisation, surtout dans des frameworks de test multithread, où des problèmes d'accès concurrent et de synchronisation peuvent survenir. Dans de tels cas, des approches plus complexes, comme l'utilisation de ThreadLocal, peuvent être nécessaires.

Où peut-on appliquer le modèle de conception Singleton dans les tests automatisés?