Utilizarea Relative Locators în Selenium: Simplificarea identificării elementelor

În automatizarea testelor cu Selenium, identificarea corectă a elementelor pe o pagină web este esențială pentru a asigura o testare stabilă și eficientă. O abordare inovatoare și utilă în acest sens este utilizarea Relative Locators, care facilitează găsirea elementelor în funcție de poziția relativă față de alte elemente. Acest articol va explora conceptul de Relative Locators și va furniza exemple de cod pentru a ilustra modul în care acestea pot fi utilizate în Selenium.

Ce sunt Relative Locators?

Relative Locators sunt o caracteristică introdusă în Selenium 4, care permite identificarea elementelor pe baza relației lor spațiale față de alte elemente. Acest lucru este deosebit de util în situații în care identificarea directă a unui element poate fi dificilă, dar poziția sa relativă față la alte elemente este cunoscută. Oferă o modalitate elegantă și eficientă de a identifica elemente pe baza relației lor spațiale față de alte elemente. Acest lucru poate facilita procesul de automatizare a testelor, în special în scenarii complexe. Integrarea Relative Locators în Selenium 4 aduce o valoare adăugată dezvoltatorilor de teste automate, sporind flexibilitatea și ușurând întreținerea testelor.

Există mai multe tipuri de Relative Locators în Selenium, printre care se numără:

  • above(): Găsește un element situat deasupra unui alt element.
  • below(): Găsește un element situat sub un alt element.
  • toLeftOf(): Găsește un element situat în stânga altui element.
  • toRightOf(): Găsește un element situat în dreapta altui element.
  • near(): Găsește un element aflat în proximitatea altui element.

Exemplu de Relative Locators în Selenium

Scenariul nostru va viza găsirea unui câmp de introducere în funcție de poziția sa relativă față de un alt element. Pentru ilustrare, vom utiliza limbajul de programare Java în combinație cu Selenium.

Vom considera un scenariu în care trebuie să identificăm un element input aflat în apropierea unui alt element pe o pagină web. Pentru a ilustra, vom utiliza Java în combinație cu Selenium. De asemenea, vom integra metodele setup() și teardown() pentru a asigura o gestionare corespunzătoare a sesiunilor de test.

În testul de mai jos, exemplificăm puterea și versatilitatea locatorilor relativi în Selenium. Folosind Relative Locator near(), identificăm un câmp de introducere situat în apropierea a două elemente de referință, un logo de imagine și un buton, evidențiind astfel capacitatea de a localiza elemente în funcție de relația lor spațială pe pagină. De asemenea, în acest exemplu, am demonstrat utilizarea metodei toRightOf și toLeftOf, care completează gama de opțiuni oferite de locatorii relativi. Aceste abordări simplifică semnificativ procesul de identificare a elementelor și adaugă flexibilitate în cadrul testelor automate.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.locators.RelativeLocator;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;



public class RelativeLocatorNearExample {

    private WebDriver driver;

	@BeforeClass
	public void setup() {
		driver = new ChromeDriver();
		driver.manage().window().maximize();
		driver.get("https://keyfood.ro/");
	}
	

	@Test
    public void nearLocatorTest() {

        // Identificarea elementului de referință (de exemplu, un label)
        WebElement referenceElement = driver.findElement(By.cssSelector("img[class*='desktop-logo']"));

        // Identificarea elementului de referință (de exemplu, un label)
        WebElement referenceElement2 = driver.findElement(By.cssSelector("div[class='button-icon']"));      

        // Utilizarea Relative Locator `near()` pentru a găsi un câmp de introducere în apropierea elementului de referință
		WebElement inputField = driver.findElement(RelativeLocator.with(By.xpath("//input")).near(referenceElement, 300).near(referenceElement2, 300));

        // Interacțiunea cu elementul găsit
        inputField.sendKeys("Hello, Near Locator!");

        //Stergerea textului din input
        inputField.clear();

        //Aceasi interactiune de data aceasta cu Relative Locator toRightOf si toLeftOf
		WebElement newInputField = driver.findElement(RelativeLocator.with(By.xpath("//input")).toRightOf(referenceElement).toLeftOf(referenceElement2));

		// Interacțiunea cu elementul găsit
		newInputField.sendKeys("Hello, toLeftOf and toRightOf Locators!");

    }


   @AfterClass
    public void tearDown(){

        // Închiderea browser-ului
        if (driver != null) {
            driver.quit();
        }
    }
}

Locatorii relativi reprezintă o adiție semnificativă în arsenalul unui tester, facilitând identificarea eficientă a elementelor pe baza relației lor spațiale. În exemplul nostru, Relative Locator near() a permis găsirea unui câmp de introducere în apropierea a două elemente distincte, simplificând astfel codul și îmbunătățind rezistența la modificări ale structurii paginii web. Această funcționalitate este deosebit de valoroasă în scenariile în care identificarea directă a elementelor poate fi dificilă sau nesustenabilă.

Prin urmare, implementarea locatorilor relativi în teste automate cu Selenium aduce beneficii semnificative, crescând eficiența și menținând stabilitatea testelor pe termen lung.

Codul poate fi gasit aici : github.com

Implementarea Setup și Teardown în testele Selenium cu TestNG și Java

Atunci când dezvoltăm teste automate pentru aplicații web cu Selenium și Java, este important să avem un mediu bine configurat pentru a asigura că testele rulează corect și eficient. O abordare comună în acest sens este utilizarea setup și teardown, oferite de framework-ul TestNG. În acest articol, vom explora cum să implementăm setup și teardown în teste Selenium folosind Java și TestNG.

Setarea mediului cu Setup

Metoda @BeforeClass din TestNG este utilizată pentru a executa cod înaintea primului test dintr-o clasă de teste. Această metodă este ideală pentru operațiile de setup care trebuie realizate o singură dată pentru întregul set de teste.

import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class SeleniumTest {

    @BeforeClass
    public void setup() {
        // Configurare WebDriver, deschidere browser, etc.
        System.out.println("Setup pentru testele Selenium");
    }

    @Test
    public void test1() {
        // Test 1
        System.out.println("Execută Test 1");
    }
}

În exemplul de mai sus, metoda setup() va fi apelată înaintea execuției oricărui test din clasă. Aici poți configura WebDriver-ul, deschide browser-ul sau executa orice alte operațiuni de setup necesare.

Cleanup cu Teardown

Metoda @AfterClass din TestNG este utilizată pentru a executa cod după ce toate testele dintr-o clasă au fost rulate. Aceasta este o oportunitate ideală pentru operațiunile de cleanup sau pentru închiderea resurselor deschise în timpul setup-ului.

import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;

public class SeleniumTest {

    @BeforeClass
    public void setup() {
        // Configurare WebDriver, deschidere browser, etc.
        System.out.println("Setup pentru testele Selenium");
    }

    @Test
    public void test1() {
        // Test 1
        System.out.println("Execută Test 1");
    }

    @Test
    public void test2() {
        // Test 2
        System.out.println("Execută Test 2");
    }

    @AfterClass
    public void teardown() {
        // Închidere browser, eliberare resurse, etc.
        System.out.println("Teardown după testele Selenium");
    }
}

Metoda teardown() este apelată după ce toate testele din clasă au fost rulate, oferind un loc potrivit pentru operațiuni de curățare și eliberare a resurselor.

O practică recomandată în dezvoltarea de teste automate este organizarea metodelor de setup și teardown într-o clasă separată, numită adesea TestBase sau BaseTest. Această clasă servește drept punct central pentru toate operațiunile de configurare și curățare și este extinsă de către clasele de teste specifice.

Avantaje ale utilizării unei Clase de Bază (BaseTest):

  1. Reutilizare a Codului: Prin plasarea metodelor de setup și teardown într-o clasă separată, poți reutiliza aceste metode în toate clasele de teste care extind această clasă de bază. Acest lucru conduce la un cod mai curat și mai ușor de întreținut.
  2. Consistență: Toate clasele de teste care extind BaseTest vor beneficia de aceeași configurare și curățare, asigurând consistența întregii suită de teste.
  3. Flexibilitate: Prin intermediul clasei de bază, poți adăuga și gestiona cu ușurință alte funcționalități globale necesare pentru testele tale, cum ar fi gestionarea datelor de test, logging-ul, sau interacțiunea cu servicii externe.

Iată un exemplu simplu pentru o clasă de bază (BaseTest) care conține metodele de setup și teardown:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;

public class BaseTest {
    protected WebDriver driver;

    @BeforeClass
    public void setup() {
        System.setProperty("webdriver.chrome.driver", "C:\\path\\to\\chromedriver.exe");
        driver = new ChromeDriver();
        driver.manage().window().maximize();
        // Alte operațiuni de configurare
    }

    @AfterClass
    public void teardown() {
        if (driver != null) {
            driver.quit();
        }
        // Alte operațiuni de curățare
    }
}

O dată ce ai definit clasa de bază, poți extinde această clasă în toate clasele tale de teste specifice, precum SeleniumTest:

import org.testng.annotations.Test;

public class SeleniumTest extends BaseTest {

    @Test
    public void test1() {
        // Test specific
        // Nu este nevoie să configurezi WebDriver-ul sau să gestionezi cleanup-ul explicit
    }

    @Test
    public void test2() {
        // Alt test specific
    }
}

Această organizare a codului facilitează menținerea și extinderea suitei de teste și contribuie la un cod mai curat și mai ușor de gestionat în timp.

Utilizarea setup și teardown în teste automate cu Selenium și Java oferă o structură bine organizată și modulară pentru gestionarea configurării și închiderii mediului de test. TestNG facilitează aceste operațiuni prin intermediul anotărilor @BeforeClass și @AfterClass. Implementând aceste practici, poți asigura că testele tale rulează într-un mediu coerent și că resursele sunt gestionate eficient.

Cum să faci un screenshot folosind librăria Selenium în Java

Selenium este o librărie populară pentru automatizarea testelor pe aplicații web. Printre numeroasele funcționalități pe care le oferă, se numără și posibilitatea de a realiza capturi de ecran (screenshot-uri) ale paginilor web. În acest articol, vom explora cum poți utiliza Selenium în Java pentru a realiza un screenshot al unei pagini web.

Pasul 1: Configurarea proiectului Java

Pentru a începe, asigură-te că ai configurat un proiect Java și ai adăugat librăria Selenium în claspath-ul proiectului tău. Poți face acest lucru prin adăugarea dependenței în fișierul de configurare Maven (pom.xml) sau prin descărcarea și adăugarea manuală a bibliotecilor Selenium.

Exemplu pentru Maven:

  <dependencies>
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>4.16.1</version> <!-- Asigură-te că utilizezi ultima versiune disponibilă -->
    </dependency>
</dependencies>

Pasul 2: Inițializarea driver-ului Selenium

Înainte de a realiza un screenshot, trebuie să inițializezi un driver Selenium pentru a controla un browser. În exemplul nostru, vom utiliza ChromeDriver.

public class HotToTakeScreenshotWithSelenium {

	
	 public static void main(String[] args) {

	        // Inițializează un obiect WebDriver pentru Chrome
	        WebDriver driver = new ChromeDriver();

	        // Deschide o pagină web
	        driver.get("https://www.keybooks.ro");

	        // Realizează un screenshot și salvează-l într-un fișier
	        try {
	            // Utilizează metoda getScreenshotAs pentru a realiza captura de ecran
	            File screenshotFile = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
	            
	            // Salvează captura de ecran într-un fișier
	            FileUtils.copyFile(screenshotFile, new File("poze/screenshot.png"));
	        } catch (IOException e) {
	            e.printStackTrace();
	        }

	        // Închide browser-ul
	        driver.quit();
	    }
	
}

Pasul 3: Adăugarea excepțiilor și importurile necesare

În exemplul de cod de mai sus, am adăugat un bloc try-catch pentru a trata excepțiile care pot apărea în timpul realizării și salvării capturii de ecran. De asemenea, am importat clasele necesare pentru a gestiona aceste operațiuni.

import java.io.File;
import java.io.IOException;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

Concluzie:
Utilizând librăria Selenium în Java, realizarea unui screenshot al unei pagini web devine o sarcină simplă. Acest exemplu furnizează o bază solidă pentru începerea automatizării testelor și a altor activități care implică capturi de ecran în cadrul proceselor de dezvoltare software.

Exemplul de cod poate fi accesat aici: github.com