
Acest Selenium tutorial te duce de la zero la primul test automat în Python: instalezi pachetul cu pip install selenium, deschizi Chrome din cod, găsești elemente pe pagină cu By, dai click și verifici rezultatul cu assert. Nu mai descarci manual niciun driver, iar primul test îl scrii în mai puțin de o oră.
Dacă vrei să înveți practic, curs testare automată online are primele lecții gratuite, cu exerciții verificate direct în browser.
Mai jos ai codul complet, rulat pe Selenium 4.52 cu Chrome în modul headless, cu rezultatul real afișat în terminal, plus greșelile pe care le face aproape orice începător și cum le repari.
Dacă vrei să exersezi testarea automată fără să instalezi nimic, cursul nostru de testare automată cu Selenium și Playwright are primele 20 de lecții gratuite, cu teste care rulează direct în browser pe un magazin online demo.
Ce este Selenium și la ce folosește
Selenium este o bibliotecă open source care controlează un browser real din cod: deschide pagini, completează formulare, apasă butoane și citește textul afișat, exact cum ar face un om. Testerii îl folosesc ca să verifice automat că o aplicație web funcționează după fiecare modificare, iar alți programatori îl folosesc pentru automatizări repetitive în browser.
Partea care contează pentru tine se numește Selenium WebDriver. WebDriver este un standard W3C, adică un set de comenzi pe care browserele le înțeleg prin intermediul unui program mic numit driver (ChromeDriver pentru Chrome, GeckoDriver pentru Firefox). Codul tău Python trimite comanda „dă click pe butonul X”, driverul o transmite browserului, iar browserul o execută.
Gândește-te la un magazin online din Cluj care are pagina de comandă. De fiecare dată când un programator schimbă ceva în coș, cineva trebuie să verifice că se mai poate plasa o comandă. Manual durează 10 minute. Un test Selenium face același lucru în câteva secunde și îl poți rula de 50 de ori pe zi. Asta înseamnă testarea automată.
Selenium funcționează cu mai multe limbaje: Java, Python, JavaScript, C# și Ruby. În acest tutorial folosim Python, pentru că are sintaxa cea mai scurtă și se instalează cel mai ușor. Există și unelte mai noi, precum Playwright, dar Selenium rămâne prezent în foarte multe proiecte existente, așa că merită să știi să lucrezi cu el.
Cum instalezi Selenium pentru Python
Instalarea înseamnă o singură comandă: pip install selenium. Ai nevoie de Python 3 instalat și de un browser (Chrome, Firefox sau Edge). Recomandarea mea este să lucrezi într-un mediu virtual, ca pachetele proiectului să nu se amestece cu restul sistemului.
python3 -m venv venv
source venv/bin/activate # pe Windows: venv\Scripts\activate
pip install selenium pytest
python -c "import selenium; print(selenium.__version__)" Pe vechile tutoriale vei vedea pași lungi: descarci ChromeDriver, verifici că versiunea se potrivește cu Chrome, îl pui în PATH. Nu mai e cazul. Începând cu versiunea 4.6, Selenium vine cu Selenium Manager, o unealtă care află ce versiune de browser ai, descarcă driverul potrivit și îl păstrează în cache. Din documentația oficială reiese că, din versiunea 4.11, poate descărca și Chrome dacă nu îl ai instalat.
În practică, asta se vede la prima rulare: la mine a durat aproape 30 de secunde, pentru că Selenium Manager a descărcat ChromeDriver în folderul ~/.cache/selenium. Următoarele rulări au pornit în câteva secunde.
Selenium tutorial: primul script cu Python, pas cu pas
Primul script deschide o pagină, verifică titlul, completează un câmp, apasă butonul de trimitere și verifică mesajul primit. Folosim pagina de test oficială a proiectului Selenium, un formular simplu făcut special pentru exerciții, ca să nu depinzi de un site care se schimbă.
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")
driver = webdriver.Chrome(options=options)
try:
driver.get("https://www.selenium.dev/selenium/web/web-form.html")
print("Titlul paginii:", driver.title)
assert driver.title == "Web form"
camp_text = driver.find_element(By.ID, "my-text-id")
camp_text.send_keys("Salut din Cluj")
buton = driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
buton.click()
mesaj = WebDriverWait(driver, 10).until(
EC.visibility_of_element_located((By.ID, "message"))
)
print("Mesaj primit:", mesaj.text)
assert mesaj.text == "Received!"
finally:
driver.quit() Salvează-l ca primul_test.py și rulează python primul_test.py. Rezultatul real:
Titlul paginii: Web form
Mesaj primit: Received! Dacă un assert nu trece, Python oprește scriptul cu AssertionError. Asta e, de fapt, un test: cod care verifică o așteptare și se plânge când nu e îndeplinită.
Ce face fiecare linie
webdriver.ChromeOptions()pregătește setările browserului.--headless=newpornește Chrome fără fereastră, util pe servere și în CI. Scoate linia dacă vrei să vezi browserul cum lucrează.--window-size=1920,1080dă ferestrei o dimensiune de laptop. Fără ea, în headless, unele butoane ajung acoperite de alte elemente (vezi greșelile de mai jos).webdriver.Chrome(options=options)pornește browserul. Aici intră în joc Selenium Manager, care găsește driverul.driver.get(url)deschide pagina și așteaptă să se încarce documentul.driver.find_element(By.ID, "my-text-id")caută un element.Byspune după ce cauți: id, nume, selector CSS, XPath.send_keys()tastează text, iarclick()apasă pe element.WebDriverWait(...).until(...)așteaptă până la 10 secunde să apară mesajul. Continuă imediat ce apare.driver.quit()închide browserul și driverul. Stă înfinally, ca să se execute chiar dacă testul pică.
Locatori în Selenium: cum găsești elementele pe pagină
Un locator este regula după care Selenium găsește un element în pagină, iar alegerea lui decide dacă testul tău rezistă la prima schimbare de design. În Selenium 4 scrii mereu find_element(By.X, "valoare"). Metodele vechi de tipul find_element_by_id au fost scoase, așa că orice tutorial care le folosește e depășit.
| Locator | Exemplu | Când îl folosești |
|---|---|---|
By.ID | (By.ID, "email") | Prima alegere, dacă elementul are un id stabil |
By.NAME | (By.NAME, "my-text") | Câmpuri de formular |
By.CSS_SELECTOR | (By.CSS_SELECTOR, "button[type='submit']") | Aproape orice altceva; e rapid și ușor de citit |
By.XPATH | (By.XPATH, "//button[text()='Trimite']") | Când cauți după text sau urci în structura paginii |
By.LINK_TEXT | (By.LINK_TEXT, "Coșul meu") | Linkuri cu text fix |
By.CLASS_NAME | (By.CLASS_NAME, "pret") | Rar; clasele se schimbă des odată cu designul |
Ordinea pe care o recomand: id, apoi name, apoi selector CSS, iar XPath doar când nu ai altă variantă. Dacă lucrezi în echipă, cere-le programatorilor să pună atribute dedicate testelor, de tipul data-testid="buton-plata", pe care le găsești cu By.CSS_SELECTOR, "[data-testid='buton-plata']". Evită XPath-urile lungi copiate din DevTools, precum /html/body/div[2]/div/form/button: se strică la primul element adăugat în pagină.
Pentru mai multe elemente folosești find_elements (cu „s”), care întoarce o listă.
Așteptări în Selenium: WebDriverWait în loc de time.sleep
Folosește așteptări explicite (WebDriverWait) și nu time.sleep(), pentru că pagina modernă încarcă datele treptat, iar un timp fix e fie prea scurt, fie prea lung. Aproape toate testele „care pică uneori” au ca sursă o așteptare greșită.
Cu time.sleep(5) testul așteaptă mereu 5 secunde, chiar dacă elementul a apărut după 0,3 secunde. Pe un server mai lent, 5 secunde pot să nu ajungă, iar testul pică fără ca aplicația să aibă vreo problemă. WebDriverWait verifică o condiție de mai multe ori pe secundă și continuă imediat ce e îndeplinită, iar dacă după timpul maxim tot nu e, aruncă TimeoutException, cu un mesaj clar.
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 10)
# așteaptă să apară și să fie vizibil
mesaj = wait.until(EC.visibility_of_element_located((By.ID, "message")))
# așteaptă să se poată da click
buton = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "button[type='submit']")))
# așteaptă un titlu anume
wait.until(EC.title_is("Web form - target page")) Mai există și așteptarea implicită, driver.implicitly_wait(10), care se aplică la fiecare find_element. Pentru început, alege una singură: așteptările explicite. Documentația Selenium despre așteptări avertizează că amestecul de așteptări implicite și explicite poate duce la timpi de așteptare greu de prevăzut.
Un test Selenium real cu pytest
Un script cu assert merge pentru început, dar teste adevărate scrii cu pytest, un framework de testare care găsește singur testele, le rulează și îți arată un raport. Fiecare funcție care începe cu test_ este un test, iar o fixture pregătește browserul înainte și îl închide după.
import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
URL = "https://www.selenium.dev/selenium/web/web-form.html"
@pytest.fixture
def driver():
options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")
driver = webdriver.Chrome(options=options)
yield driver
driver.quit()
def test_titlul_paginii(driver):
driver.get(URL)
assert driver.title == "Web form"
def test_trimite_formularul(driver):
driver.get(URL)
driver.find_element(By.NAME, "my-text").send_keys("Ana Popescu")
driver.find_element(By.NAME, "my-password").send_keys("parola123")
driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()
mesaj = WebDriverWait(driver, 10).until(
EC.visibility_of_element_located((By.ID, "message"))
)
assert mesaj.text == "Received!"
def test_campul_dezactivat(driver):
driver.get(URL)
camp = driver.find_element(By.NAME, "my-disabled")
assert not camp.is_enabled() Salvează-l ca test_formular.py (numele trebuie să înceapă cu test_) și rulează pytest -v test_formular.py. Rezultatul de la mine:
collected 3 items
test_formular.py::test_titlul_paginii PASSED [ 33%]
test_formular.py::test_trimite_formularul PASSED [ 66%]
test_formular.py::test_campul_dezactivat PASSED [100%]
============== 3 passed in 4.28s ============== Fiecare test primește un browser nou, deci testele nu se influențează între ele. Când suita crește, următorul pas este Page Object Model, adică o clasă pentru fiecare pagină, cu locatorii și acțiunile ei, ca să nu repeți aceiași selectori în 20 de teste.
Greșeli frecvente când înveți Selenium
Majoritatea erorilor de început vin din trei surse: elementul nu e încă pe pagină, elementul e acoperit de altceva sau codul copiat e scris pentru o versiune veche de Selenium. Iată ce vei întâlni cel mai des.
Butonul există, dar click-ul dă ElementClickInterceptedException
Prima mea rulare a testului de mai sus, fără dimensiunea ferestrei, a picat exact așa:
selenium.common.exceptions.ElementClickInterceptedException:
Message: element click intercepted: Element is not clickable at point (151, 857) În modul headless, Chrome pornește cu o fereastră mică, iar butonul ajunge sub alt element. Soluția este --window-size=1920,1080 sau derularea până la element înainte de click. Nu rezolva cu time.sleep, problema nu e de timp.
NoSuchElementException pe un element care se vede în pagină
De obicei elementul apare după o cerere spre server, iar find_element a căutat prea devreme. Folosește WebDriverWait cu condiția potrivită. Dacă elementul e într-un iframe, intră întâi în el cu driver.switch_to.frame(...).
AttributeError: ‘WebDriver’ object has no attribute ‘find_element_by_id’
Ai copiat cod dintr-un tutorial scris pentru Selenium 3. Înlocuiește find_element_by_id("x") cu find_element(By.ID, "x") și importă By din selenium.webdriver.common.by.
Browserul rămâne deschis după test
Ai uitat driver.quit() sau ai pus-o după un assert care a picat. Pune închiderea în finally sau într-o fixture pytest, ca în exemplu. driver.close() închide doar fila curentă, nu și driverul.
Exercițiu pentru tine
Pe aceeași pagină de test, scrie un test pytest care alege o opțiune din lista derulantă și verifică selecția. Indiciu: importă Select din selenium.webdriver.support.ui, găsește elementul cu By.NAME, "my-select", apoi folosește select_by_visible_text("Two") și verifică first_selected_option.text. Al doilea pas: bifează un checkbox și verifică is_selected().
Ce înveți după primul test Selenium
După ce primul test trece, următorii pași sunt organizarea testelor și rularea lor automat la fiecare modificare a codului. Concret, înveți Page Object Model, date de test parametrizate (@pytest.mark.parametrize), capturi de ecran la eșec, testarea API-urilor și rularea suitei în CI, de exemplu cu GitHub Actions. În paralel merită să știi bazele testării manuale: cum alegi ce să testezi contează mai mult decât unealta.
Dacă te gândești la o carieră în domeniu, citește și cum devii QA tester fără experiență, iar pentru drumul complet, de la testare manuală la automatizare, uită-te la traseul QA Engineer.
Întrebări frecvente
Ce este Selenium, pe scurt?
Selenium este o bibliotecă open source care controlează un browser real din cod. O folosești ca să scrii teste automate pentru aplicații web: deschizi pagini, completezi formulare, dai click și verifici ce apare. Funcționează cu Chrome, Firefox, Edge și Safari.
Selenium cu Python sau cu Java?
Pentru primul test, Python, pentru că scrii mai puțin cod și instalarea e mai simplă. Comenzile WebDriver sunt aceleași în toate limbajele, deci ce înveți se transferă ușor. Alege limbajul pe care îl folosește echipa în care vrei să lucrezi; în multe proiecte enterprise vei găsi Java.
Mai trebuie să descarc ChromeDriver?
Nu, de la Selenium 4.6 încolo. Selenium Manager detectează versiunea browserului, descarcă driverul potrivit și îl păstrează în cache. Descarci manual doar în situații speciale, de exemplu într-o rețea de firmă care blochează descărcările.
Selenium este gratuit?
Da. Selenium este open source, sub licența Apache 2.0, și îl poți folosi gratuit și în proiecte comerciale. Plătești doar dacă alegi servicii externe care rulează testele pe multe browsere în cloud.
Cât durează să înveți Selenium?
Primul test îl scrii într-o seară, dacă știi bazele Python. Ca să scrii teste stabile, cu așteptări corecte, Page Object Model și rulare în CI, socotește câteva săptămâni de exercițiu constant. Cel mai mult timp îl iau locatorii buni și depanarea testelor instabile, nu sintaxa.
Se mai folosește Selenium în 2026?
Da. Selenium WebDriver este un standard W3C și rămâne folosit în multe proiecte existente, mai ales în Java și C#. Playwright este alegerea frecventă în proiectele noi, de aceea e util să le cunoști pe amândouă.
Primul pas: rulează testul de azi
Copiază scriptul primul_test.py, instalează Selenium și rulează-l. Apoi scoate opțiunea headless și privește browserul cum completează formularul singur: e momentul în care automatizarea începe să aibă sens.
Când vrei să treci de la scripturi izolate la o suită de teste ca într-un proiect real, începe cursul de Test Automation cu Playwright și Selenium. Primele 20 de lecții sunt gratuite, fără card, iar testele rulează în browser pe ShopRapid, un magazin demo cu bug-uri ascunse pe care testele tale trebuie să le prindă. Cursul folosește JavaScript, iar conceptele din acest tutorial (locatori, așteptări, aserțiuni) se regăsesc identic acolo.
Curs Test Automation (Playwright și Selenium)
Testare automată cu Playwright și Selenium, pas cu pas
Începe gratuit
