Gdzie w testach automatycznych można zastosować…

W testach automatycznych Singleton jest często używany do zarządzania zasobami, które muszą mieć pojedynczy egzemplarz przez całą sesję testową.

Przykłady zastosowania:

Zarządzanie WebDriver: Zapewnienie pojedynczego egzemplarza obiektu WebDriver, z którego korzystają wszystkie klasy testowe. Pozwala to uniknąć wielokrotnego otwierania/zamykania przeglądarki i zachowania stanu między krokami testu.

public class WebDriverSingleton {
    private static WebDriver instance;

    private WebDriverSingleton() {
        // Prywatny konstruktor, aby zapobiec tworzeniu instancji
    }

    public static WebDriver getInstance() {
        if (instance == null) {
            // Inicjalizacja WebDriver (np. Chrome, Firefox)
            instance = new ChromeDriver();
        }
        return instance;
    }

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

// Użycie w klasie testowej
public class MyTests {
    @BeforeClass
    public void setup() {
        WebDriver driver = WebDriverSingleton.getInstance();
        // Użycie driver
    }

    @AfterClass
    public void tearDown() {
        WebDriverSingleton.quitDriver();
    }
    // Metody testowe
}

Zarządzanie połączeniem z bazą danych: Gwarancja, że istnieje tylko jedno aktywne połączenie z bazą danych do wykonywania warunków wstępnych testu lub sprawdzania danych.

public class DatabaseConnection {
    private static Connection instance;

    private DatabaseConnection() {
        // Prywatny konstruktor
    }

    public static Connection getInstance() {
        if (instance == null) {
            try {
                // Ustanowienie połączenia z bazą danych
                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();
            }
        }
    }
}

Zarządzanie plikiem konfiguracyjnym: Wczytywanie parametrów konfiguracyjnych z pliku na początku uruchomienia testu i zapewnienie do nich jednolitego dostępu.

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("Przepraszam, nie można znaleźć 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);
    }
}

Zarządzanie logowaniem: Pojedynczy egzemplarz loggera do centralnego prowadzenia logów testowych.

Użycie Singleton pomaga zarządzać zasobami, które wymagają unikalności, ale należy być ostrożnym w jego użyciu, szczególnie w wielowątkowych frameworkach testowych, gdzie mogą wystąpić problemy z dostępem współbieżnym i konieczność synchronizacji. W takich przypadkach mogą być potrzebne bardziej złożone podejścia, np. użycie ThreadLocal.

Gdzie w testach automatycznych można zastosować wzorzec Singleton?