Python Test FrameworksPython Test Framework'leri

pip install selenium webdriver-manager pytest

import pytest
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

@pytest.fixture(scope="function")
def driver():
    options = webdriver.ChromeOptions()
    options.add_argument("--headless")
    options.add_argument("--window-size=1280,720")
    options.add_argument("--no-sandbox")

    service = Service(ChromeDriverManager().install())
    drv = webdriver.Chrome(service=service, options=options)
    drv.implicitly_wait(10)  # default wait
    yield drv
    drv.quit()               # always closes browser

from selenium.webdriver.common.by import By

# ── Preferred order ──
el = driver.find_element(By.ID, "submit-btn")         # ✅ Best: unique, fast
el = driver.find_element(By.CSS_SELECTOR, "#submit")  # ✅ Good: CSS power
el = driver.find_element(By.CSS_SELECTOR, ".form .btn[type='submit']")
el = driver.find_element(By.XPATH, "//button[@data-testid='submit']")

# ── Multiple elements ──
items = driver.find_elements(By.CSS_SELECTOR, "li.product")
count = len(items)

# ── Relative Locators (Selenium 4) ──
from selenium.webdriver.support.relative_locator import locate_with

password_label = driver.find_element(By.ID, "password-label")
password_field = driver.find_element(
    locate_with(By.TAG_NAME, "input").to_right_of(password_label)
)

# ── Bad practices to avoid ──
# ❌ driver.find_element(By.XPATH, "/html/body/div[3]/form/input[2]")
# ❌ driver.find_element(By.CLASS_NAME, "btn")  # class names change

from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys

# ── Basic actions ──
driver.get("https://example.com/login")
driver.find_element(By.ID, "email").send_keys("admin@test.com")
driver.find_element(By.ID, "password").send_keys("secret")
driver.find_element(By.ID, "submit").click()

# ── Keyboard shortcuts ──
field = driver.find_element(By.ID, "search")
field.send_keys("pytest")
field.send_keys(Keys.ENTER)                       # press Enter
field.send_keys(Keys.CONTROL + "a")               # Ctrl+A

# ── Advanced: ActionChains ──
actions = ActionChains(driver)

# Hover over element
menu = driver.find_element(By.ID, "nav-menu")
actions.move_to_element(menu).perform()

# Drag and drop
source = driver.find_element(By.ID, "drag-item")
target = driver.find_element(By.ID, "drop-zone")
actions.drag_and_drop(source, target).perform()

# Double click
actions.double_click(driver.find_element(By.ID, "item")).perform()

# ── JavaScript execution ──
driver.execute_script("window.scrollTo(0, document.body.scrollHeight)")
driver.execute_script("arguments[0].click();", element)  # bypass overlays

# ── Screenshots ──
driver.save_screenshot("screenshots/login_page.png")
element.screenshot("screenshots/button.png")  # element-level

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

wait = WebDriverWait(driver, timeout=10)

# ── Most common conditions ──
el = wait.until(EC.presence_of_element_located((By.ID, "modal")))
el = wait.until(EC.visibility_of_element_located((By.ID, "result")))
el = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "#submit")))
wait.until(EC.url_contains("/dashboard"))
wait.until(EC.title_is("Dashboard"))
wait.until(EC.text_to_be_present_in_element((By.ID, "msg"), "Success"))

# ── Wait for element to DISAPPEAR ──
wait.until(EC.invisibility_of_element_located((By.ID, "loading-spinner")))

# ── Custom wait condition ──
def element_has_class(locator, cls):
    def check(driver):
        el = driver.find_element(*locator)
        return cls in el.get_attribute("class")
    return check

wait.until(element_has_class((By.ID, "btn"), "active"))

def test_valid_login(driver):
    login_page = LoginPage(driver)
    driver.get("https://example.com/login")

    dashboard = login_page.login("admin@test.com", "secret")

    assert dashboard.get_welcome_message() == "Welcome, Admin!"
    assert dashboard.is_logged_in()

def test_invalid_login(driver):
    login_page = LoginPage(driver)
    driver.get("https://example.com/login")
    login_page.login("wrong@test.com", "badpass")

    assert login_page.get_error_message() == "Invalid credentials"

pip install playwright pytest-playwright
playwright install               # downloads Chromium, Firefox, WebKit
playwright install chromium      # or just one browser

[pytest]
addopts = --browser chromium --headed
base_url = https://example.com

from playwright.sync_api import Page, expect

def test_checkout_flow(page: Page):
    page.goto("/shop")

    # ── Playwright auto-waits before each action ──
    page.click(".add-to-cart")         # waits until button is clickable
    page.click("#cart-icon")           # waits until visible
    page.click("text=Proceed to Pay")  # text locator!

    page.fill("#card-number", "4111111111111111")
    page.select_option("#expiry-month", "12")
    page.click("#pay-btn")

    # ── Assertions with built-in retry ──
    expect(page.locator(".order-confirmation")).to_be_visible()
    expect(page.locator(".order-id")).to_have_text(r"ORD-\d{6}")

    # ── Only use explicit waits for tricky cases ──
    page.wait_for_url("**/confirmation")
    page.wait_for_selector(".success-msg", state="visible")
    page.wait_for_load_state("networkidle")

    # ── When you NEED to wait for an element to be GONE ──
    page.wait_for_selector("#loading-spinner", state="hidden")

from playwright.sync_api import Page, Route
import json

def test_with_mocked_api(page: Page):
    """Intercept API call and return fake data — no real backend needed."""

    def handle_users(route: Route):
        route.fulfill(
            status=200,
            content_type="application/json",
            body=json.dumps([
                {"id": 1, "name": "Alice", "role": "admin"},
                {"id": 2, "name": "Bob",   "role": "user"},
            ])
        )

    page.route("**/api/users", handle_users)
    page.goto("/users")

    expect(page.locator(".user-row")).to_have_count(2)
    expect(page.locator(".user-row").first).to_contain_text("Alice")

def test_block_analytics(page: Page):
    """Block tracking/analytics requests to speed up tests."""
    page.route("**/*google-analytics*", lambda r: r.abort())
    page.route("**/*hotjar*", lambda r: r.abort())
    page.goto("/")

def test_api_directly(page: Page):
    """Use Playwright's APIRequestContext — no requests library needed."""
    resp = page.request.post(
        "https://api.example.com/login",
        data={"email": "admin@test.com", "password": "secret"},
    )
    assert resp.ok
    token = resp.json()["token"]
    assert token.startswith("eyJ")

from playwright.sync_api import Page, Locator, expect

class LoginPage:
    # ── Locators as properties ──
    def __init__(self, page: Page):
        self.page = page
        self.email: Locator    = page.locator("#email")
        self.password: Locator = page.locator("#password")
        self.submit: Locator   = page.get_by_role("button", name="Sign In")
        self.error: Locator    = page.locator(".error-message")

    def navigate(self):
        self.page.goto("/login")

    def login(self, email: str, password: str) -> "DashboardPage":
        self.email.fill(email)
        self.password.fill(password)
        self.submit.click()
        return DashboardPage(self.page)

    def expect_error(self, message: str):
        expect(self.error).to_be_visible()
        expect(self.error).to_have_text(message)


class DashboardPage:
    def __init__(self, page: Page):
        self.page = page
        self.welcome = page.locator("h1.welcome")
        self.logout_btn = page.get_by_role("button", name="Logout")

    def expect_loaded(self):
        expect(self.page).to_have_url("/dashboard")
        expect(self.welcome).to_be_visible()


# ── Test using POM ──
def test_login_success(page: Page):
    lp = LoginPage(page)
    lp.navigate()
    dashboard = lp.login("admin@test.com", "secret")
    dashboard.expect_loaded()

def test_login_invalid(page: Page):
    lp = LoginPage(page)
    lp.navigate()
    lp.login("wrong@example.com", "bad")
    lp.expect_error("Invalid credentials")