Dove si può applicare il pattern Singleton nei test…

Nei test automatizzati, il pattern Singleton viene spesso utilizzato per gestire risorse che devono avere un'unica istanza durante tutta la sessione di test.

Esempi di utilizzo:

Gestione di WebDriver: Per garantire un'unica istanza dell'oggetto WebDriver, utilizzata da tutte le classi di test. Questo evita di aprire/chiudere ripetutamente il browser e mantiene lo stato tra i passaggi di test.

public class WebDriverSingleton {
    private static WebDriver instance;

    private WebDriverSingleton() {
        // Costruttore privato per impedire la creazione di istanze
    }

    public static WebDriver getInstance() {
        if (instance == null) {
            // Inizializzazione di WebDriver (ad esempio, Chrome, Firefox)
            instance = new ChromeDriver();
        }
        return instance;
    }

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

// Uso nella classe di test
public class MyTests {
    @BeforeClass
    public void setup() {
        WebDriver driver = WebDriverSingleton.getInstance();
        // Uso di driver
    }

    @AfterClass
    public void tearDown() {
        WebDriverSingleton.quitDriver();
    }
    // Metodi di test
}

Gestione della connessione al database: Garantisce che ci sia una sola connessione attiva al database per eseguire precondizioni di test o verifiche sui dati.

public class DatabaseConnection {
    private static Connection instance;

    private DatabaseConnection() {
        // Costruttore privato
    }

    public static Connection getInstance() {
        if (instance == null) {
            try {
                // Stabilire connessione al database
                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();
            }
        }
    }
}

Gestione del file di configurazione: Caricamento dei parametri di configurazione da un file all'inizio dell'esecuzione del test e fornitura di un accesso unico ad essi.

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("Spiacente, impossibile trovare 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);
    }
}

Gestione del logging: Un singolo esempio di logger per la gestione centralizzata dei log di esecuzione del test.

L'uso di Singleton aiuta a gestire risorse che richiedono unicità, ma bisogna fare attenzione al suo utilizzo, specialmente in framework di test multithread, dove possono sorgere problemi di accesso concorrente e necessità di sincronizzazione. In tali casi, possono essere necessari approcci più complessi, come l'uso di ThreadLocal.

Dove si può applicare il pattern Singleton nei test automatizzati?