⚙️ End-to-End Test Automation, Protocol Architecture & SDET Engineering
Modern automated software quality engineering demands a fundamental departure from legacy HTTP-based WebDriver protocols. Enterprise engineering interviews for SDET and automation roles assess direct browser protocol communication, event-driven WebSocket connections, resilient locator strategies, web-first polling assertions, network virtualization, and headless parallel execution. Below are 100 comprehensive technical questions and practical answers across 8 core operational domains.
Q1: What is Microsoft Playwright, and what problem does it solve in modern automated testing?
ANSWER:
Playwright is an open-source automation library created by Microsoft designed for end-to-end web testing. Unlike older frameworks that rely on third-party drivers (such as the HTTP-based WebDriver in Selenium), Playwright communicates directly with the browser's native debugging protocol (like Chrome DevTools Protocol) over a single persistent WebSocket connection. This architecture eliminates HTTP command-response overhead, prevents flaky tests with native auto-waiting, supports full multi-page/multi-tab workflows, and enables direct execution across Chromium, Firefox, and WebKit using a unified API.
Q2: What is the architectural difference between Playwright and Selenium WebDriver?
ANSWER:
- Protocol & Communication: Selenium uses the W3C WebDriver specification, sending discrete HTTP JSON requests via a driver executable (e.g., chromedriver) to the browser for every command. Playwright maintains a bi-directional, single WebSocket connection directly to the browser.
- Speed & Latency: Playwright has lower round-trip latency because it uses event-driven, binary-efficient WebSocket frames instead of repeated HTTP handshakes.
- Waits & Synchronization: Selenium requires manual configuration of implicit or explicit polling waits. Playwright performs automatic actionability checks (visible, stable, enabled) before triggering interactions.
- Execution Boundary: Playwright runs natively inside the browser context, enabling network interception, mocking, and console telemetry.
Q3: How do you install Playwright with Python and download required browser binaries?
ANSWER:
# Install the core Playwright library and the pytest-playwright plugin
pip install playwright pytest-playwright
# Download the bundled patched browser binaries (Chromium, Firefox, WebKit)
playwright install
# Download system-level OS dependencies (useful for headless Linux/CI)
playwright install --with-deps
Q4: What is the difference between Playwright Synchronous and Asynchronous APIs in Python?
ANSWER:
- Synchronous API (sync_api): Blocks the execution thread until the browser command completes. It is standard for linear automated testing frameworks (like standard pytest) and is simpler to write and debug.
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page()
page.goto("https://example.com")
browser.close()
- Asynchronous API (async_api): Built on Python's native asyncio loop (async/await). It enables non-blocking, concurrent browser operations, web scraping pipelines, and integration with asynchronous web frameworks.
import asyncio
from playwright.async_api import async_playwright
async def main():
async with async_playwright() as p:
browser = await p.chromium.launch()
page = await browser.new_page()
await page.goto("https://example.com")
await browser.close()
asyncio.run(main())
Q5: Explain the hierarchy of Browser, BrowserContext, and Page in Playwright.
ANSWER:
- Browser: An actual running instance of a browser process (e.g., Chromium headless process). It is resource-heavy to launch.
- BrowserContext: An isolated, lightweight incognito-equivalent session inside a single Browser instance. It has its own independent cache, cookies, local storage, proxy settings, and session state without incurring process-launch overhead.
- Page: A single tab or window within a specific BrowserContext. Multiple pages within the same context share session cookies and local storage.
HIERARCHICAL MAP:
Browser (Process)
├── BrowserContext 1 (Incognito Session: User A)
│ ├── Page 1 (Tab 1)
│ └── Page 2 (Tab 2)
└── BrowserContext 2 (Incognito Session: User B)
└── Page 3 (Tab 1)
Q6: How do you launch a visible (headed) browser and slow down operations for debugging?
ANSWER:
Pass headless=False to make the browser visible, and set slow_mo (in milliseconds) to throttle action execution:
browser = playwright.chromium.launch(headless=False, slow_mo=500)
Q7: What are the three core browser engines natively supported by Playwright?
ANSWER:
1. Chromium: Used by Google Chrome, Microsoft Edge, Opera, and Brave.
2. Firefox: Mozilla's browser engine (Gecko).
3. WebKit: Apple's open-source rendering engine that powers Safari. Playwright builds and runs WebKit across Windows, Linux, and macOS.
Q8: What is codegen, and how is it used to scaffold Playwright scripts?
ANSWER:
codegen is Playwright's built-in CLI test recorder. It opens a real browser alongside an inspector window that records your clicks, keystrokes, and navigations, generating production-ready Python code with user-facing locators in real time:
playwright codegen https://example.com
To generate asynchronous Python code:
playwright codegen --target python-async https://example.com
Q9: What is pytest-playwright, and what fixtures does it provide automatically?
ANSWER:
pytest-playwright is the official plugin connecting Playwright to the pytest runner. It provides pre-configured fixtures with automatic lifecycle teardown:
- page: Provides an isolated new browser Page instance per test function.
- context: Provides an isolated BrowserContext instance.
- browser: The launched Browser instance shared across worker sessions.
- browser_name: Returns the name of the browser engine under test (e.g., chromium).
- browser_type_launch_args: Customizes browser launch dictionaries.
Q10: How do you pass custom viewport configurations and device emulations to a browser context?
ANSWER:
# Custom dimensions
context = browser.new_context(
viewport={"width": 1280, "height": 720},
locale="en-GB",
timezone_id="Europe/London"
)
# Pre-configured device emulation
iphone = playwright.devices["iPhone 14 Pro"]
context = browser.new_context(**iphone)
Q11: What is the purpose of running tests across multiple browsers via CLI?
ANSWER:
When using pytest-playwright, you can drive multi-browser execution via CLI flags without modifying code:
# Run against all three major engines concurrently
pytest --browser chromium --browser firefox --browser webkit
Q12: How do you capture video recordings of test runs in Playwright?
ANSWER:
Configure the record_video_dir parameter within the browser context:
context = browser.new_context(
record_video_dir="videos/",
record_video_size={"width": 1280, "height": 720}
)
page = context.new_page()
# ... perform test actions ...
context.close() # Video saving finalizes when the context is closed
print(page.video.path())
Q13: What is the trace viewer, and how do you record a test trace?
ANSWER:
Playwright Trace Viewer is a GUI tool that lets you view test execution after the fact. It provides DOM snapshots for every action, timeline scrubbing, network request timelines, console logs, and source locations:
context.tracing.start(screenshots=True, snapshots=True, sources=True)
page = context.new_page()
page.goto("https://example.com")
# ... test steps ...
context.tracing.stop(path="trace.zip")
Inspect via CLI:
playwright show-trace trace.zip
Q14: How do you configure HTTP proxy settings in Playwright?
ANSWER:
Pass a proxy dictionary into launch() or new_context():
browser = playwright.chromium.launch(
proxy={
"server": "http://myproxy.corp.com:8080",
"username": "proxy_user",
"password": "proxy_password"
}
)
Q15: How do you take a full-page screenshot versus an element screenshot?
ANSWER:
# Full-page screenshot (scrolls through the full height of the body)
page.screenshot(path="full_page.png", full_page=True)
# Element-specific screenshot (captures bounding box)
page.locator("#submit-button").screenshot(path="button.png")
Q16: What is the fundamental difference between page.locator() and legacy page.query_selector()?
ANSWER:
- page.locator() creates a lazy, re-evaluating representation of a DOM element. It evaluates when an action (click, fill) occurs, supports auto-waiting, and automatically re-fetches elements to eliminate StaleElementExceptions.
- page.query_selector() (or page.$()) returns an immediate, static ElementHandle. It does not auto-wait and throws stale element reference errors if the DOM updates after retrieval. Locators are the standard best practice.
Q17: List the recommended user-facing role locators in Playwright and give examples.
ANSWER:
# Accessibility role and accessible name
page.get_by_role("button", name="Submit Order")
page.get_by_role("checkbox", name="Subscribe to newsletter")
# Placeholder text
page.get_by_placeholder("Enter your corporate email")
# Associated form labels
page.get_by_label("Password")
# User-visible text
page.get_by_text("Welcome back, Admin")
# Alternative text on visual media
page.get_by_alt_text("Company Logo")
# Title attribute
page.get_by_title("Close dialog")
Q18: What is get_by_test_id(), and how do you configure a custom test ID attribute?
ANSWER:
get_by_test_id() targets resilient test hooks (defaulting to data-testid). You can customize the recognized attribute via playwright.selectors:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
p.selectors.set_test_id_attribute("data-automation-id")
# ...
page.get_by_test_id("checkout-submit-btn").click()
Q19: Explain the concept of "Auto-Waiting" and what checks Playwright runs before clicking an element.
ANSWER:
Before triggering an action like locator.click(), Playwright runs Actionability Checks, waiting until the element:
1. Is attached to the DOM.
2. Is visible (non-empty bounding box, not display: none, not visibility: hidden).
3. Is stable (not animating or moving).
4. Can receive pointer events (not obscured by an overlay, modal, or loader).
5. Is enabled (not disabled via HTML attributes).
If these checks fail within the timeout period (default: 30s), a TimeoutError is raised.
Q20: How do you filter locators using .filter()?
ANSWER:
You can refine a locator matching multiple elements using text criteria or nested child locator criteria:
# Match a row inside a table that contains specific text
row = page.locator("tr").filter(has_text="Invoice #1042")
# Match a card container that contains a specific button inside it
card = page.locator(".card").filter(has=page.locator("button.delete-btn"))
card.get_by_role("button", name="Delete").click()
Q21: How do you locate an element inside an open Shadow DOM root in Playwright?
ANSWER:
Playwright penetrates open Shadow DOM trees by default across all selector engines (CSS, text). No extra syntax or context-switching code is required:
# Automatically pierces through Shadow DOM boundaries
page.locator("custom-input-component input.inner-field").fill("Secret")
Q22: What is the chaining syntax for locators in Playwright?
ANSWER:
Chaining narrows the scope of an element query within a parent container:
modal = page.locator(".modal-dialog")
modal.get_by_role("button", name="Confirm").click()
Q23: How do you select an item from a standard HTML <select> dropdown?
ANSWER:
# Select by value
page.locator("#country-select").select_option(value="IN")
# Select by visible label
page.locator("#country-select").select_option(label="India")
# Select multiple options
page.locator("#multi-tags").select_option(value=["python", "playwright"])
Q24: How do you work with checkboxes and radio buttons?
ANSWER:
Use check(), uncheck(), and verify their states with assertions:
checkbox = page.get_by_label("I agree to terms")
checkbox.check()
assert checkbox.is_checked()
checkbox.uncheck()
assert not checkbox.is_checked()
Q25: How do you click an element if it is strictly matching the exact text without substrings?
ANSWER:
Pass exact=True into get_by_text() or get_by_role():
# Will match only "Submit", not "Submit Order" or "Submitting"
page.get_by_text("Submit", exact=True).click()
Q26: How do you iterate over multiple matching elements using a locator?
ANSWER:
Use locator.all() to retrieve a Python list of resolved locators:
items = page.locator("ul.product-list > li").all()
for item in items:
print(item.text_content())
Q27: What is the difference between locator.inner_text(), locator.text_content(), and locator.input_value()?
ANSWER:
- inner_text(): Returns the rendered text as displayed to the human user (respects CSS transforms and visibility).
- text_content(): Returns all text inside the node including hidden elements, script tags, and comments.
- input_value(): Reads the current value entered into an <input> or <textarea> element.
Q28: How do you handle pseudo-classes like :has-text() and :visible in Playwright CSS selectors?
ANSWER:
Playwright extends the standard CSS engine with custom pseudo-classes:
# Targets a button with text "Logout"
page.locator("button:has-text('Logout')").click()
# Targets only elements that are currently visible
page.locator(".toast-message:visible").click()
Q29: What is the difference between page.fill() and page.type() / page.locator.press_sequentially()?
ANSWER:
- fill(): Clears the existing text in one operation and sets the input field's value directly, firing input, change, and blur events. It is fast and recommended for most forms.
- press_sequentially() (formerly type()): Simulates real human typing by dispatching discrete keydown, keypress, and keyup events for each character with optional delays. Useful for autosuggest search inputs.
page.locator("#search").press_sequentially("Data Science", delay=100)
Q30: How do you locate an element using XPath in Playwright?
ANSWER:
Prepend the selector string with xpath= or start directly with //:
page.locator("//div[@class='profile']//span[text()='Active']").click()
Q31: How do you handle mouse drag-and-drop operations in Playwright?
ANSWER:
# High-level method
source = page.locator("#drag-item")
target = page.locator("#drop-container")
source.drag_to(target)
# Manual mouse dispatch
source.hover()
page.mouse.down()
target.hover()
page.mouse.up()
Q32: How do you hover over an element and execute double-click or right-click?
ANSWER:
# Hover
page.get_by_role("menuitem", name="Settings").hover()
# Double click
page.get_by_text("Double click me").dblclick()
# Right-click (context menu)
page.locator(".file-node").click(button="right")
Q33: How do you upload single and multiple files into file input fields?
ANSWER:
Use set_input_files():
# Single file upload
page.locator('input[type="file"]').set_input_files("receipt.pdf")
# Multiple files upload
page.locator('input[type="file"][multiple]').set_input_files(["doc1.pdf", "doc2.pdf"])
# Clear uploaded files
page.locator('input[type="file"]').set_input_files([])
Q34: How do you handle file uploads triggered by clicking a button (non-input element)?
ANSWER:
Use page.expect_file_chooser():
with page.expect_file_chooser() as fc_info:
page.get_by_text("Upload Profile Picture").click()
file_chooser = fc_info.value
file_chooser.set_files("avatar.png")
Q35: How do you automate file downloads and retrieve the downloaded file path?
ANSWER:
with page.expect_download() as download_info:
page.get_by_role("button", name="Download Report").click()
download = download_info.value
# Save the downloaded binary to a permanent directory
download.save_as(f"reports/{download.suggested_filename}")
Q36: How do you automate native JavaScript dialogs (alert, confirm, prompt)?
ANSWER:
Playwright automatically dismisses dialogs by default so tests don't freeze. To interact with them, register a dialog handler:
def handle_dialog(dialog):
print(f"Dialog text: {dialog.message}")
dialog.accept() # Or dialog.dismiss()
page.on("dialog", handle_dialog)
page.get_by_role("button", name="Delete Account").click()
# Providing input to a JS prompt
page.on("dialog", lambda dialog: dialog.accept("My custom input response"))
Q37: How do you interact with elements embedded inside an iframe?
ANSWER:
Use page.frame_locator():
# Locate elements inside an iframe by CSS selector targeting the iframe
frame = page.frame_locator("#payment-iframe")
frame.get_by_placeholder("Card Number").fill("411111111111")
frame.get_by_role("button", name="Pay Now").click()
Q38: How do you switch between and interact with multiple tabs or popup windows?
ANSWER:
with page.expect_popup() as popup_info:
page.get_by_role("link", name="Open Terms in New Tab").click()
new_tab = popup_info.value
new_tab.wait_for_load_state()
print(new_tab.title())
new_tab.get_by_role("button", name="Accept").click()
new_tab.close()
# Resume operations on original page
page.bring_to_front()
Q39: How do you simulate key combinations (e.g., keyboard shortcuts) in Playwright?
ANSWER:
# Select all and delete text
page.locator("#code-editor").click()
page.keyboard.press("Control+A") # Use Meta+A for macOS
page.keyboard.press("Backspace")
# Press Enter
page.keyboard.press("Enter")
Q40: How do you scroll pages or elements into view?
ANSWER:
Playwright automatically scrolls elements into view before clicking. To scroll explicitly:
# Scroll a specific element into view
page.locator("footer .copyright").scroll_into_view_if_needed()
# Scroll using mouse wheel
page.mouse.wheel(delta_x=0, delta_y=1000)
# Scroll via JavaScript evaluation
page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
Q41: How do you bypass animations that cause flaky interactions in Playwright?
ANSWER:
Pass no_wait_after=True or use CSS to disable animations across the page:
# Avoid waiting for action navigations
page.get_by_role("button").click(no_wait_after=True)
# Turn off CSS animations on the page
page.add_style_tag(content="*, *::before, *::after { transition: none !important; animation: none !important; }")
Q42: What is the difference between page.wait_for_selector() and locator.wait_for()?
ANSWER:
page.wait_for_selector() is an older, legacy API that works with raw CSS/XPath strings. locator.wait_for() is the modern API that uses Playwright's locator architecture and accepts fine-grained lifecycle states:
# States: 'attached', 'detached', 'visible', 'hidden'
page.locator(".loading-spinner").wait_for(state="hidden", timeout=10000)
Q43: How do you run JavaScript code directly within the browser context and return values?
ANSWER:
Use page.evaluate() or locator.evaluate():
# Return page dimensions
dimensions = page.evaluate("() => ({ width: window.innerWidth, height: window.innerHeight })")
print(dimensions["width"])
# Pass Python arguments into the browser JavaScript engine
result = page.evaluate("(multiplier) => document.querySelectorAll('p').length * multiplier", 10)
# Evaluate on a specific element
color = page.locator("h1").evaluate("el => window.getComputedStyle(el).color")
Q44: How do you manage browser permissions (e.g., Geolocation, Camera, Notifications)?
ANSWER:
Grant permissions via the browser context:
context = browser.new_context(
permissions=["geolocation", "notifications"],
geolocation={"latitude": 18.5204, "longitude": 73.8567} # Pune, India coordinates
)
page = context.new_page()
page.goto("https://maps.google.com")
Q45: How do you force a click on an element that is technically obscured or not actionable?
ANSWER:
Pass force=True to the click action. This bypasses actionability checks and dispatches the pointer event directly:
page.locator("#hidden-link").click(force=True)
Q46: How does Playwright intercept network requests using page.route()?
ANSWER:
page.route() intercepts HTTP/HTTPS requests that match a URL pattern. You can modify them, abort them, or return a mock response without reaching the network:
def intercept(route):
if "ads.tracker.com" in route.request.url:
route.abort()
else:
route.continue_()
page.route("**/*", intercept)
page.goto("https://example.com")
Q47: How do you mock an API endpoint to return a custom JSON payload?
ANSWER:
def mock_api(route):
route.fulfill(
status=200,
content_type="application/json",
body='{"status": "success", "user": {"id": 101, "name": "B.Tech QA"}}'
)
page.route("**/api/v1/user/profile", mock_api)
page.goto("https://example.com/dashboard")
Q48: How do you modify a live API response before it reaches the frontend application?
ANSWER:
Fetch the original response from the real server, modify it, and fulfill it:
def modify_response(route):
response = route.fetch() # Perform actual upstream network request
json_data = response.json()
json_data["experimental_feature_flag"] = True # Inject property
route.fulfill(
response=response,
json=json_data
)
page.route("**/api/features", modify_response)
page.goto("https://example.com")
Q49: How do you block unnecessary assets (images, fonts, stylesheets) to speed up execution?
ANSWER:
page.route(
"**/*.{png,jpg,jpeg,svg,woff,woff2,css}",
lambda route: route.abort()
)
page.goto("https://example.com")
Q50: How do you wait for a specific backend network request or response before proceeding?
ANSWER:
with page.expect_response("**/api/orders/create") as response_info:
page.get_by_role("button", name="Place Order").click()
response = response_info.value
assert response.status == 201
data = response.json()
assert data["order_status"] == "CONFIRMED"
Q51: How do you use Playwright's APIRequestContext for direct REST API testing without opening a browser?
ANSWER:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
request = p.request.new_context(base_url="https://jsonplaceholder.typicode.com")
# Send a POST request
response = request.post(
"/posts",
data={"title": "Playwright Automation", "body": "B.Tech Guide", "userId": 1},
headers={"Content-Type": "application/json"}
)
assert response.status == 201
assert response.json()["id"] == 101
request.dispose()
Q52: How do you capture console logs and unhandled JavaScript errors from a webpage?
ANSWER:
# Listen for console messages
page.on("console", lambda msg: print(f"Console {msg.type}: {msg.text}"))
# Listen for page crash / uncaught exceptions
page.on("pageerror", lambda error: print(f"Uncaught JS Exception: {error}"))
Q53: How do you modify outgoing HTTP request headers (e.g., adding an Authorization token)?
ANSWER:
def add_auth_header(route):
headers = route.request.headers
headers["Authorization"] = "Bearer eyJhbGciOiJIUzI1NiIsIn..."
route.continue_(headers=headers)
page.route("**/api/secure/**", add_auth_header)
Q54: What is the difference between page.wait_for_load_state() options: load, domcontentloaded, and networkidle?
ANSWER:
- load: Resolves when the window.onload event fires (all initial assets like stylesheets and images are loaded).
- domcontentloaded: Resolves when the basic HTML structure is parsed and DOM is constructed (does not wait for external stylesheets or images).
- networkidle: Resolves when there are no new network requests for at least 500 ms. This is useful for Single Page Applications (SPAs) loading data dynamically.
Q55: How do you capture and inspect WebSocket frames in Playwright?
ANSWER:
def on_web_socket(ws):
print(f"WebSocket Opened: {ws.url}")
ws.on("framesent", lambda payload: print(f"Frame Sent: {payload}"))
ws.on("framereceived", lambda payload: print(f"Frame Received: {payload}"))
page.on("websocket", on_web_socket)
page.goto("https://example.com/live-chat")
Q56: How do you simulate an offline network environment in Playwright?
ANSWER:
context = browser.new_context()
page = context.new_page()
# Go offline
context.set_offline(True)
# Attempt navigation
try:
page.goto("https://example.com")
except Exception as e:
print("Caught expected network failure while offline")
# Restore connectivity
context.set_offline(False)
Q57: How do you assert that a specific network request was made with correct payload parameters?
ANSWER:
with page.expect_request(
lambda req: req.method == "POST" and "api/login" in req.url
) as request_info:
page.get_by_role("button", name="Log In").click()
request = request_info.value
post_data = request.post_data_json
assert post_data["username"] == "admin"
Q58: How do you handle HTTP Basic Authentication in Playwright?
ANSWER:
Set credentials directly in the context configuration:
context = browser.new_context(
http_credentials={"username": "qa_user", "password": "secure_password"}
)
page = context.new_page()
page.goto("https://staging.internal.net")
Q59: How do you handle SSL/TLS certificate errors during test runs?
ANSWER:
Use the ignore_https_errors option:
browser = playwright.chromium.launch()
context = browser.new_context(ignore_https_errors=True)
page = context.new_page()
page.goto("https://self-signed.badssl.com/")
Q60: How do you record and mock HAR (HTTP Archive) files?
ANSWER:
# Record network interactions into a HAR file
context = browser.new_context(record_har_path="archive.har")
page = context.new_page()
page.goto("https://example.com")
context.close()
# Replay requests locally from the recorded HAR file (no live internet required)
page.route_from_har("archive.har")
page.goto("https://example.com")
Q61: What is storage state (storage_state), and why is it important in test automation?
ANSWER:
storage_state is a snapshot of all cookies, local storage items, and session storage keys within an authenticated browser context. Playwright can save this state to a JSON file and restore it in future contexts, bypassing the login UI in downstream tests. This reduces authentication overhead across test suites.
Q62: How do you implement a global authentication flow that saves credentials to a JSON file?
ANSWER:
from playwright.sync_api import sync_playwright
def save_login_state():
with sync_playwright() as p:
browser = p.chromium.launch()
context = browser.new_context()
page = context.new_page()
page.goto("https://example.com/login")
page.get_by_label("Username").fill("admin_user")
page.get_by_label("Password").fill("Secret123")
page.get_by_role("button", name="Sign In").click()
page.wait_for_url("**/dashboard")
# Dump cookies and local storage to disk
context.storage_state(path="auth_state.json")
browser.close()
Q63: How do you reuse a saved storage_state.json file in a new test?
ANSWER:
from playwright.sync_api import sync_playwright
def test_user_dashboard():
with sync_playwright() as p:
browser = p.chromium.launch()
# Initialize context directly with authenticated session state
context = browser.new_context(storage_state="auth_state.json")
page = context.new_page()
page.goto("https://example.com/dashboard")
# Direct access without login screens
page.get_by_role("heading", name="Welcome back, Admin").wait_for()
browser.close()
Q64: How do you inspect, add, and clear browser cookies programmatically?
ANSWER:
# Read all cookies in the context
all_cookies = context.cookies()
# Add a session cookie
context.add_cookies([
{
"name": "session_token",
"value": "xyz123abc456",
"domain": "example.com",
"path": "/",
"httpOnly": True,
"secure": True
}
])
# Delete all cookies
context.clear_cookies()
Q65: How do you manipulate browser LocalStorage and SessionStorage in Playwright?
ANSWER:
Use page.evaluate() to interact with window storage objects:
# Set LocalStorage item
page.evaluate("window.localStorage.setItem('theme', 'dark')")
# Retrieve item
theme = page.evaluate("window.localStorage.getItem('theme')")
# Clear LocalStorage
page.evaluate("window.localStorage.clear()")
# Manipulate SessionStorage
page.evaluate("window.sessionStorage.setItem('cart_id', '9999')")
Q66: How do you test multiple user personas (e.g., Admin vs. Normal User) concurrently in a single test?
ANSWER:
Create multiple independent BrowserContext instances within the same Browser:
def test_chat_interaction(browser):
# Admin context
admin_ctx = browser.new_context(storage_state="admin_auth.json")
admin_page = admin_ctx.new_page()
# User context
user_ctx = browser.new_context(storage_state="user_auth.json")
user_page = user_ctx.new_page()
# Both users interact on the same application in real-time
admin_page.goto("https://chat.example.com")
user_page.goto("https://chat.example.com")
user_page.get_by_placeholder("Send message").fill("Hello Support")
user_page.keyboard.press("Enter")
admin_page.get_by_text("Hello Support").wait_for()
Q67: How do you configure pytest-playwright to automatically reuse storage_state across tests?
ANSWER:
Configure the default context args in conftest.py:
# conftest.py
import pytest
@pytest.fixture(scope="session")
def browser_context_args(browser_context_args):
return {
**browser_context_args,
"storage_state": "auth_state.json"
}
Q68: How do you test login functionality with Two-Factor Authentication (2FA/TOTP)?
ANSWER:
Use the pyotp library to generate dynamic TOTP tokens within the test script:
import pyotp
# User enters initial credentials
page.get_by_label("Username").fill("admin")
page.get_by_label("Password").fill("password123")
page.get_by_role("button", name="Continue").click()
# Generate real-time 6-digit TOTP code using user's secret key
totp = pyotp.TOTP("JBSWY3DPEHPK3PXP")
current_otp = totp.now()
# Fill OTP into UI
page.get_by_label("Two-Factor Code").fill(current_otp)
page.get_by_role("button", name="Verify").click()
Q69: How do you clear browser cache and indexedDB storage in Playwright?
ANSWER:
Close and recreate the BrowserContext to clear non-persistent state cleanly. To clear indexedDB explicitly on an open page:
page.evaluate("window.indexedDB.databases().then(dbs => dbs.forEach(db => window.indexedDB.deleteDatabase(db.name)))")
Q70: How do you verify an application's behavior when an authentication token expires mid-session?
ANSWER:
page.goto("https://example.com/account")
# Clear the authorization cookie to simulate token expiration
context.clear_cookies()
# Trigger an action requiring authentication
page.get_by_role("button", name="Update Profile").click()
# Verify redirect to login screen
page.wait_for_url("**/login?error=session_expired")
Q71: What are web-first assertions, and how do they differ from standard Python assertions?
ANSWER:
- Standard Python assertions (assert a == b): Evaluate once, synchronously. If the DOM has not finished rendering when the line runs, the test fails immediately with an AssertionError.
- Playwright Web-First Assertions (expect(locator)): Wait and poll the DOM continuously until the condition is met or the timeout expires. They account for asynchronous frontend state changes.
from playwright.sync_api import expect
# Anti-pattern: Prone to flakiness
assert page.locator(".status").text_content() == "Loaded"
# Best Practice: Polls until the condition is true or timeout is reached
expect(page.locator(".status")).to_have_text("Loaded")
Q72: List 10 common web-first assertions provided by Playwright.
ANSWER:
1. expect(locator).to_be_visible()
2. expect(locator).to_be_hidden()
3. expect(locator).to_be_enabled()
4. expect(locator).to_be_disabled()
5. expect(locator).to_be_checked()
6. expect(locator).to_have_text("Expected String")
7. expect(locator).to_contain_text("Partial Substring")
8. expect(locator).to_have_value("Form input value")
9. expect(locator).to_have_count(5)
10. expect(page).to_have_url("https://example.com/success")
Q73: How do you assert negative conditions (e.g., an element disappears) using web-first assertions?
ANSWER:
Chain .not_ before the assertion method:
# Polls until the modal is removed or hidden
expect(page.locator(".loading-overlay")).not_.to_be_visible()
# Asserts an input does not have a specific validation error class
expect(page.locator("#username")).not_.to_have_class("input-error")
Q74: How do you customize the timeout and error message of a specific web-first assertion?
ANSWER:
expect(page.locator(".alert-success")).to_be_visible(
timeout=10000,
message="Expected success alert to be rendered within 10 seconds!"
)
Q75: Why is page.wait_for_timeout() considered an anti-pattern, and what should be used instead?
ANSWER:
page.wait_for_timeout(5000) pauses the entire execution thread for a fixed duration. This slows down test suites if the wait is too long, or causes intermittent failures in CI if the wait is too short. Instead, wait for an explicit state change:
# Instead of: page.wait_for_timeout(5000)
# Wait for target locator state:
page.locator("#results-table").wait_for(state="visible")
# Or use web-first assertions:
expect(page.locator(".record-item")).to_have_count(10)
Q76: How do you wait for a custom JavaScript condition to evaluate to true?
ANSWER:
Use page.wait_for_function():
# Wait until an internal JavaScript array on window has at least 3 items
page.wait_for_function("window.dataCollection && window.dataCollection.length >= 3")
Q77: How do you handle common exceptions like TimeoutError in Playwright tests?
ANSWER:
Import exceptions from playwright.sync_api:
from playwright.sync_api import TimeoutError
try:
page.locator(".promo-banner").click(timeout=3000)
except TimeoutError:
print("Promotional popup did not appear, proceeding with checkout.")
Q78: How do you configure visual regression testing (snapshot comparison) with Playwright?
ANSWER:
Use expect(page).to_have_screenshot():
def test_homepage_visuals(page):
page.goto("https://example.com")
# Compares current screen render to a stored baseline golden image
expect(page).to_have_screenshot("homepage_baseline.png", max_diff_pixels=50)
Q79: How do you mask dynamic or fluctuating page elements during visual comparison?
ANSWER:
Pass a list of locators to the mask parameter:
# Masks out dynamic live clock or ads to prevent false visual failures
expect(page).to_have_screenshot(
"dashboard.png",
mask=[page.locator(".current-timestamp"), page.locator("#ad-banner")]
)
Q80: How do you write an assertion verifying that an HTTP response has a specific status and body structure?
ANSWER:
response = page.request.get("https://api.example.com/status")
expect(response).to_be_ok() # Verifies HTTP status code is in 200..299 range
data = response.json()
assert data["database"] == "UP"
Q81: What is the Page Object Model (POM), and why is it used?
ANSWER:
Page Object Model is a design pattern that wraps a web page (or component) in a dedicated Python class. The class encapsulates locators, element interactions, and page-specific operations, while test scripts call high-level methods. This separates test logic from UI selectors, so if the DOM updates, changes are made in one central Page Object rather than across dozens of individual tests.
Q82: Provide a complete Python implementation of a Page Object Model class using Playwright.
ANSWER:
# pages/login_page.py
from playwright.sync_api import Page, Locator, expect
class LoginPage:
def __init__(self, page: Page):
self.page = page
self.username_input: Locator = page.get_by_label("Username")
self.password_input: Locator = page.get_by_label("Password")
self.login_button: Locator = page.get_by_role("button", name="Log In")
self.error_message: Locator = page.locator(".alert-danger")
def navigate(self):
self.page.goto("/login")
def login(self, username: str, password: str):
self.username_input.fill(username)
self.password_input.fill(password)
self.login_button.click()
def verify_login_error(self, expected_error: str):
expect(self.error_message).to_contain_text(expected_error)
Q83: How do you write a Pytest test using the LoginPage Page Object?
ANSWER:
# tests/test_login.py
from pages.login_page import LoginPage
def test_invalid_login(page):
login_page = LoginPage(page)
login_page.navigate()
login_page.login("invalid_user", "WrongPassword!")
login_page.verify_login_error("Invalid credentials provided")
Q84: How do you construct custom reusable fixtures in conftest.py with Pytest and Playwright?
ANSWER:
# conftest.py
import pytest
from pages.login_page import LoginPage
from pages.dashboard_page import DashboardPage
@pytest.fixture
def login_page(page):
return LoginPage(page)
@pytest.fixture
def authenticated_dashboard(page, login_page):
login_page.navigate()
login_page.login("standard_user", "ValidPassword123")
return DashboardPage(page)
Q85: How do you execute Playwright tests in parallel using pytest-xdist?
ANSWER:
# Install pytest-xdist
pip install pytest-xdist
# Run tests across 4 parallel worker processes
pytest -n 4
# Run with auto-detection of available CPU cores
pytest -n auto
Q86: How do you run tests in headless versus headed mode via Pytest CLI?
ANSWER:
# Run headless (default mode for CI/CD)
pytest --headed=false
# Run headed (opens actual browser GUI)
pytest --headed
Q87: How do you capture an automatic screenshot only when a test fails in Pytest?
ANSWER:
Configure the CLI flag provided by pytest-playwright:
pytest --screenshot only-on-failure --output ./test-results/
Or hook into Pytest's lifecycle in conftest.py:
# conftest.py
import pytest
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
outcome = yield
report = outcome.get_result()
if report.when == "call" and report.failed:
page = item.funcargs.get("page", None)
if page:
page.screenshot(path=f"failures/{item.name}.png")
Q88: How do you parameterize test cases with diverse datasets in Playwright?
ANSWER:
Use pytest.mark.parametrize:
import pytest
@pytest.mark.parametrize("user,pwd,expected_error", [
("empty_user", "", "Password cannot be blank"),
("locked_user", "pass123", "User account is locked"),
("non_existent", "pass123", "User does not exist"),
])
def test_login_scenarios(page, user, pwd, expected_error):
page.goto("/login")
page.get_by_label("Username").fill(user)
page.get_by_label("Password").fill(pwd)
page.get_by_role("button", name="Submit").click()
expect(page.locator(".error-msg")).to_have_text(expected_error)
Q89: How do you organize tests using Pytest markers (e.g., smoke, regression)?
ANSWER:
Mark tests with @pytest.mark:
# test_checkout.py
import pytest
@pytest.mark.smoke
def test_quick_checkout(page):
pass
@pytest.mark.regression
def test_complex_tax_calculation(page):
pass
Execute from terminal:
pytest -m smoke
Q90: What is the pytest.ini configuration file, and how does it configure Playwright test suites?
ANSWER:
pytest.ini defines root configurations, CLI flags, log behavior, and custom markers:
[pytest]
addopts = --browser chromium --browser firefox --headed=false --tracing retain-on-failure --screenshot only-on-failure
testpaths = tests
markers =
smoke: Critical paths
regression: Full regression test suite
Q91: Provide a GitHub Actions YAML workflow for running Playwright Python tests in a CI/CD pipeline.
ANSWER:
name: Playwright Tests
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.11'
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Install Playwright Browsers & OS dependencies
run: playwright install --with-deps
- name: Run Playwright Tests
run: pytest --tracing retain-on-failure
- name: Upload Test Report & Artifacts
if: always()
uses: actions/upload-artifact@v4
with:
name: playwright-artifacts
path: |
test-results/
trace.zip
Q92: How do you configure and run Playwright tests inside an official Docker container?
ANSWER:
Use Microsoft's pre-configured Docker image containing all dependencies and browser engines:
FROM mcr.microsoft.com/playwright/python:v1.45.0-jammy
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["pytest", "--browser", "chromium"]
Run container:
docker run --rm -v $(pwd)/reports:/app/reports my-playwright-tests
Q93: How do you run accessibility (a11y) audits using Playwright and Axe-core?
ANSWER:
Integrate axe-core-python:
from axe_core_python.sync_playwright import Axe
def test_accessibility(page):
page.goto("https://example.com")
axe = Axe()
results = axe.run(page)
# Assert zero critical violations
critical_violations = [v for v in results["violations"] if v["impact"] == "critical"]
assert len(critical_violations) == 0, f"Accessibility errors: {critical_violations}"
Q94: How do you measure frontend web performance metrics (Core Web Vitals) in Playwright?
ANSWER:
Extract performance timing metrics via JavaScript evaluation:
def test_performance(page):
page.goto("https://example.com")
performance_timing = page.evaluate("() => JSON.stringify(window.performance.timing)")
paint_metrics = page.evaluate("""() => {
const entries = performance.getEntriesByType('paint');
return entries.map(e => ({ name: e.name, startTime: e.startTime }));
}""")
print("Paint Entries:", paint_metrics)
Q95: How do you automate Chrome Extensions with Playwright?
ANSWER:
Extensions require a persistent browser context and a headed Chromium instance:
path_to_extension = "./my-extension"
context = playwright.chromium.launch_persistent_context(
user_data_dir="/tmp/chrome-user-data",
headless=False,
args=[
f"--disable-extensions-except={path_to_extension}",
f"--load-extension={path_to_extension}"
]
)
page = context.pages[0]
page.goto("chrome://extensions")
Q96: What is the difference between browser.new_context() and chromium.launch_persistent_context()?
ANSWER:
- new_context(): Creates a non-persistent, in-memory context. When closed, all session history, cache, and local storage data are destroyed.
- launch_persistent_context(): Binds the browser session to a physical directory on disk (user_data_dir). It persists profiles, cached items, and authentication between script runs, similar to opening your day-to-day desktop browser.
Q97: How do you test Geolocation-based behavior and simulate location changes?
ANSWER:
# Configure initial location
context = browser.new_context(
permissions=["geolocation"],
geolocation={"latitude": 40.7128, "longitude": -74.0060} # New York
)
page = context.new_page()
page.goto("https://my-location-finder.com")
# Update location mid-test
context.set_geolocation({"latitude": 35.6762, "longitude": 139.6503}) # Tokyo
page.reload()
Q98: How do you mock the client system's preferred color scheme (Dark/Light mode)?
ANSWER:
Set color_scheme on the context:
context = browser.new_context(color_scheme="dark")
page = context.new_page()
page.goto("https://example.com")
# Verify page applied dark theme stylesheet
background = page.locator("body").evaluate("el => window.getComputedStyle(el).backgroundColor")
assert background == "rgb(18, 18, 18)"
Q99: How do you handle file downloads in headless Linux environments without a display server?
ANSWER:
Playwright natively routes downloaded binary streams directly via the DevTools protocol rather than opening OS file manager windows. Call .save_as() to save the file:
with page.expect_download() as download_info:
page.locator("#download-btn").click()
download = download_info.value
# Writes directly to a container/server path headlessly
download.save_as("/var/data/exports/file.csv")
Q100: How do you capture complete HAR files alongside Traces on test failures for debugging CI runs?
ANSWER:
# conftest.py
import pytest
@pytest.fixture(autouse=True)
def run_around_tests(context, request):
# Start tracing and recording HAR prior to test execution
context.tracing.start(screenshots=True, snapshots=True, sources=True)
yield
# After test completes, inspect if test failed
if hasattr(request.node, "rep_call") and request.node.rep_call.failed:
test_name = request.node.name
context.tracing.stop(path=f"artifacts/trace_{test_name}.zip")
else:
context.tracing.stop()