Jak Zacząć Pracę z Selenium: Przewodnik Krok po Kroku dla Początkujących

Selenium to popularny framework open-source umożliwiający automatyzację testów stron internetowych w różnych przeglądarkach. Narzędzie oferuje szerokie możliwości — od prostego nagrywania testów bez kodowania po zaawansowane skrypty w Pythonie, Javie czy JavaScripcie.

W tym przewodniku przeprowadzimy Cię krok po kroku przez proces rozpoczęcia pracy z Selenium — od instalacji i konfiguracji środowiska, przez tworzenie pierwszych testów, aż po najlepsze praktyki stosowane w profesjonalnych projektach testowych.

---

Instalacja i konfiguracja środowiska Selenium

Wymagania systemowe

Przed instalacją Selenium upewnij się, że Twój system spełnia podstawowe wymagania:

• System operacyjny: Windows 10/8/7 lub Linux Ubuntu 16.04+
• Pamięć RAM: minimum 2 GB (zalecane 4 GB)
• Wolne miejsce na dysku: minimum 2,5 GB
• Rozdzielczość ekranu: minimum 1024×768
• Przeglądarka: najnowsza wersja Chrome, Firefox lub Edge

Instalacja Selenium WebDriver dla Python

Instalacja Selenium WebDriver w Pythonie jest bardzo prosta dzięki menedżerowi pakietów pip. Wymagany jest Python 3.5 lub nowszy.

Podstawowa instalacja:

pip install selenium

Zalecane jest użycie wirtualnego środowiska, aby uniknąć konfliktów z innymi projektami:

python -m venv selenium_env
selenium_env\Scripts\activate       # Windows
source selenium_env/bin/activate    # Linux/Mac
pip install selenium

Konfiguracja sterowników przeglądarek

Każda przeglądarka wymaga własnego sterownika (driver), który pełni rolę pośrednika między Selenium a przeglądarką:

• ChromeDriver — dla Google Chrome
• GeckoDriver — dla Mozilla Firefox
• EdgeDriver — dla Microsoft Edge

Sterowniki można pobrać z oficjalnych stron i dodać do zmiennej PATH systemu operacyjnego. Jednak od wersji Selenium 4.6.0 dostępny jest Selenium Manager, który automatycznie wykrywa, pobiera i konfiguruje niezbędne sterowniki — eliminując konieczność ręcznej konfiguracji.

Weryfikacja poprawności instalacji

Po instalacji warto zweryfikować, czy wszystko działa prawidłowo:

from selenium import webdriver

# Inicjalizacja przeglądarki
driver = webdriver.Chrome()  # lub Firefox(), Edge()

# Otworzenie strony testowej
driver.get("https://www.example.com")

# Wyświetlenie tytułu strony
print("Tytuł strony:", driver.title)

# Zamknięcie przeglądarki
driver.quit()

Jeśli skrypt otworzy przeglądarkę, wyświetli stronę i zamknie się bez błędów — instalacja przebiegła pomyślnie.

---

Tworzenie pierwszego testu w Selenium WebDriver

Struktura podstawowego skryptu testowego

Każdy test Selenium składa się z pięciu głównych kroków:

1. Import bibliotek i inicjalizacja przeglądarki
2. Nawigacja do testowanej strony
3. Lokalizacja elementów na stronie
4. Interakcja z elementami (klikanie, wpisywanie tekstu)
5. Weryfikacja rezultatów i zamknięcie przeglądarki

Przykład kompletnego testu:

from selenium import webdriver
from selenium.webdriver.common.by import By

# Inicjalizacja przeglądarki
driver = webdriver.Chrome()

# Nawigacja do strony
driver.get("https://przykladowastrona.pl")

# Lokalizacja elementu i interakcja
element = driver.find_element(By.ID, "search")
element.send_keys("test")
element.submit()

# Weryfikacja rezultatu
assert "Wyniki wyszukiwania" in driver.title

# Zamknięcie przeglądarki
driver.quit()

Uruchamianie przeglądarki i nawigacja

Selenium obsługuje wszystkie popularne przeglądarki:

driver = webdriver.Chrome()    # Google Chrome
driver = webdriver.Firefox()   # Mozilla Firefox
driver = webdriver.Edge()      # Microsoft Edge

Nawigacja do strony:

driver.get("https://www.przykladowastrona.pl")

Dodatkowe metody nawigacji:

driver.back()       # Cofnij
driver.forward()    # Do przodu
driver.refresh()    # Odśwież stronę

Lokalizowanie elementów na stronie

Lokalizacja elementów to kluczowa umiejętność w pracy z Selenium. Dostępne metody wyszukiwania:

• By.ID — wyszukiwanie po identyfikatorze (najbardziej niezawodne, zalecane)
• By.NAME — wyszukiwanie po atrybucie name
• By.CLASS_NAME — wyszukiwanie po klasie CSS
• By.TAG_NAME — wyszukiwanie po tagu HTML
• By.CSS_SELECTOR — wyszukiwanie za pomocą selektora CSS
• By.XPATH — wyszukiwanie za pomocą wyrażenia XPath
• By.LINK_TEXT — wyszukiwanie po pełnym tekście linku
• By.PARTIAL_LINK_TEXT — wyszukiwanie po fragmencie tekstu linku

Przykłady użycia:

# Wyszukiwanie po ID (zalecane)
element = driver.find_element(By.ID, "login-form")

# Wyszukiwanie po selektorze CSS
element = driver.find_element(By.CSS_SELECTOR, "div.container > input[type='text']")

# Wyszukiwanie po XPath
element = driver.find_element(By.XPATH, "//button[@class='submit-btn']")

# Wyszukiwanie wielu elementów
elements = driver.find_elements(By.CLASS_NAME, "product-card")

Hierarchia niezawodności lokatorów: ID > Name > CSS Selector > XPath. Zaleca się używanie identyfikatorów (ID) tam, gdzie to możliwe, ponieważ są unikalne i najszybsze w wyszukiwaniu.

Interakcja z elementami strony

Po zlokalizowaniu elementu można wykonać na nim różne akcje:

# Kliknięcie elementu
element.click()

# Wprowadzenie tekstu do pola
element.send_keys("Przykładowy tekst")

# Czyszczenie pola tekstowego
element.clear()

# Zatwierdzenie formularza
element.submit()

# Pobranie tekstu elementu
tekst = element.text

# Pobranie atrybutu elementu
href = element.get_attribute("href")

# Sprawdzenie widoczności elementu
czy_widoczny = element.is_displayed()

Weryfikacja rezultatów testu

Asercje pozwalają zweryfikować, czy test zakończył się oczekiwanym wynikiem:

# Sprawdzenie tytułu strony
assert "Oczekiwany tytuł" in driver.title

# Sprawdzenie tekstu elementu
element_tekst = driver.find_element(By.CLASS_NAME, "wynik").text
assert "Sukces" in element_tekst

# Sprawdzenie, czy element jest wyświetlany
assert driver.find_element(By.ID, "success-message").is_displayed()

# Sprawdzenie aktualnego URL
assert "dashboard" in driver.current_url

---

Rozwiązywanie typowych problemów początkujących

Problemy z lokalizacją elementów

Błąd NoSuchElementException to najczęstszy problem początkujących. Może wskazywać na:

• Źle zbudowany lokator — literówka w ID, niepoprawny XPath
• Znalezienie się na innej stronie niż oczekiwana
• Element w ramce (iframe) — wymaga przełączenia kontekstu
• Element w Shadow DOM — wymaga specjalnego dostępu
• Element nie zdążył się załadować — strona nie zakończyła ładowania

Rozwiązanie: sprawdź lokator w konsoli przeglądarki (F12), upewnij się, że element istnieje na stronie i stosuj oczekiwania (waits) zamiast sztywnych opóźnień.

Obsługa iframe:

# Przełączenie na iframe
driver.switch_to.frame("nazwa_iframe")

# Wykonanie akcji wewnątrz iframe
element = driver.find_element(By.ID, "element-w-iframe")

# Powrót do głównego dokumentu
driver.switch_to.default_content()

Obsługa dynamicznych elementów i oczekiwanie

Współczesne strony internetowe ładują treść dynamicznie (AJAX, SPA). Błąd StaleElementReferenceException oznacza, że element zmienił się w DOM od momentu jego zlokalizowania.

Explicit Wait (zalecane) — czeka na spełnienie określonego warunku:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Czekaj, aż element będzie klikalny (max 10 sekund)
element = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "myButton"))
)

# Czekaj, aż element będzie widoczny
element = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.CLASS_NAME, "result"))
)

# Czekaj, aż element będzie obecny w DOM
element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "myElement"))
)

Implicit Wait — ustawia globalny czas oczekiwania:

driver.implicitly_wait(10)  # sekundy

Unikaj time.sleep() — to najgorsze rozwiązanie, bo zawsze czeka ustaloną liczbę sekund, nawet jeśli element pojawił się wcześniej.

Debugowanie testów Selenium

Skuteczne techniki debugowania:

• Punkty przerwania (breakpoints) w IDE — pozwalają zatrzymać test i sprawdzić stan
• Wykonywanie krok po kroku — driver.execute_script() w konsoli
• Zrzuty ekranu — nieocenione przy diagnostyce błędów:

driver.save_screenshot("debug_screen.png")

• Logi konsoli przeglądarki — pozwalają wykryć błędy JavaScript:

logs = driver.get_log("browser")
for log in logs:
    print(log)

---

Najlepsze praktyki automatyzacji testów

Page Object Pattern

Page Object Pattern (POP) to wzorzec projektowy, który oddziela logikę testu od lokatorów elementów. Każda strona aplikacji jest reprezentowana przez osobną klasę:

class LoginPage:
    def __init__(self, driver):
        self.driver = driver
        self.username_input = (By.ID, "username")
        self.password_input = (By.ID, "password")
        self.login_button = (By.ID, "login")
        self.error_message = (By.CLASS_NAME, "error")

    def login(self, username, password):
        self.driver.find_element(*self.username_input).send_keys(username)
        self.driver.find_element(*self.password_input).send_keys(password)
        self.driver.find_element(*self.login_button).click()

    def get_error_message(self):
        return self.driver.find_element(*self.error_message).text

Użycie w teście:

def test_login_with_valid_credentials():
    driver = webdriver.Chrome()
    driver.get("https://app.example.com/login")

    login_page = LoginPage(driver)
    login_page.login("[email protected]", "password123")

    assert "Dashboard" in driver.title
    driver.quit()

Zalety Page Object Pattern:

• Łatwość utrzymania — zmiana lokatora wymaga edycji tylko jednego miejsca
• Czytelność testów — test opisuje co robi, nie jak lokalizuje elementy
• Reużywalność — ten sam Page Object używany w wielu testach

Integracja z pytest

pytest to najpopularniejszy framework testowy w Pythonie, doskonale współpracujący z Selenium:

import pytest
from selenium import webdriver

@pytest.fixture
def driver():
    driver = webdriver.Chrome()
    driver.implicitly_wait(10)
    yield driver
    driver.quit()

def test_homepage_title(driver):
    driver.get("https://example.com")
    assert "Example" in driver.title

def test_search_functionality(driver):
    driver.get("https://example.com")
    search = driver.find_element(By.ID, "search")
    search.send_keys("selenium")
    search.submit()
    results = driver.find_elements(By.CLASS_NAME, "result")
    assert len(results) > 0

Uruchomienie testów:

# Uruchom wszystkie testy
pytest tests/ -v

# Uruchom konkretny plik
pytest tests/test_login.py -v

# Uruchom z raportem HTML
pytest tests/ --html=report.html

Integracja z CI/CD

Selenium integruje się z popularnymi narzędziami CI/CD, umożliwiając automatyczne uruchamianie testów po każdej zmianie w kodzie:

• Jenkins — uruchamianie testów jako krok w pipeline
• GitLab CI — testy w kontenerach Docker z przeglądarką headless
• GitHub Actions — automatyzacja testów na każdy pull request
• Azure DevOps — integracja z systemem raportowania

Przykład konfiguracji dla trybu headless (bez interfejsu graficznego), niezbędnego w środowiskach CI/CD:

from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument("--headless")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")

driver = webdriver.Chrome(options=options)

Automatyczne uruchamianie testów po zmianach w kodzie zapewnia szybkie wykrywanie regresji i utrzymanie jakości aplikacji.

---

Wnioski

Selenium stanowi potężne narzędzie do automatyzacji testów, które znacznie usprawnia proces weryfikacji aplikacji internetowych. Kluczowe wnioski z tego przewodnika:

• Łatwy start — instalacja sprowadza się do jednej komendy pip install selenium, a Selenium Manager automatycznie zarządza sterownikami
• Elastyczność — obsługa wielu przeglądarek, języków programowania i frameworków testowych
• Explicit Wait — zawsze preferuj jawne oczekiwania zamiast time.sleep() lub Implicit Wait
• Page Object Pattern — niezbędny wzorzec w profesjonalnych projektach, oddzielający logikę testu od struktury strony
• CI/CD — integracja z pipeline'ami zapewnia ciągłą weryfikację jakości kodu

Systematyczne podejście do nauki, znajomość rozwiązań typowych problemów oraz regularna praktyka to klucze do sukcesu w automatyzacji testów. Zacznij od prostych scenariuszy i stopniowo zwiększaj ich złożoność, wdrażając kolejne wzorce i techniki.

Jeśli potrzebujesz wsparcia w automatyzacji testów lub wdrożeniu Selenium w swoim projekcie, skontaktuj się z nami. W FoxLink Automation pomagamy firmom budować frameworki testowe, wdrażać Page Object Pattern oraz integrować testy automatyczne z pipeline'ami CI/CD.