playwright-rust

To use Playwright, initialize the driver, prepare the browsers, and then launch a specific browser type (Chromium, Firefox, or WebKit). The library uses a builder pattern for functions with multiple optional arguments to compensate for Rust's lack of default arguments.

use playwright::Playwright;

#[tokio::main]
async fn main() -> Result<(), playwright::Error> {
    let playwright = Playwright::initialize().await?;
    playwright.prepare()?; // Install browsers
    let chromium = playwright.chromium();
    let browser = chromium.launcher().headless(true).launch().await?;
    let context = browser.context_builder().build().await?;
    let page = context.new_page().await?;
    page.goto_builder("https://example.com/").goto().await?;

    // Exec in browser and Deserialize with serde
    let s: String = page.eval("() => location.href").await?;
    assert_eq!(s, "https://example.com/");
    page.click_builder("a").click().await?;
    Ok(())
}

The Page struct provides methods to control a single tab or a Chromium extension background page. It is the primary interface for browser automation tasks like navigation, element interaction, and script execution.

Common tasks include:

• Navigation: Using goto_builder() to navigate to a URL.
• Interaction: Using builders like click_builder(), fill_builder(), or type_builder() to interact with elements.
• Evaluation: Running JavaScript via eval() or evaluate() to interact with the page context.
• Screenshots/PDFs: Capturing the page state using screenshot_builder() or pdf_builder().

// Conceptual example of Page usage
let browser = await chromium.launch();
let context = await browser.new_context();
let page = await context.new_page();

await page.goto_builder("https://example.com").wait_until(DocumentLoadState::Load).reload().await?;
await page.click_builder("#submit-button").click().await?;
let title = await page.title().await?;

The accessibility tree is a representation of the page used by assistive technologies. Because different platforms and screen readers interpret this tree differently, Playwright provides an abstraction to access this tree directly from the browser engine (Chromium, Firefox, or WebKit).

To make the tree easier to process, Playwright's snapshot() method defaults to interesting_only: true, which discards nodes that are typically ignored by most screen readers. You can traverse the returned SnapshotResponse (which represents the root node) by recursively checking its children property.

// Conceptual logic for finding a focused node in a snapshot
fn find_focused_node(node: &SnapshotResponse) -> Option<&SnapshotResponse> {
    if node.focused {
        return Some(node);
    }
    for child in node.children.as_ref()? {
        if let Some(found) = find_focused_node(child) {
            return Some(found);
        }
    }
    None
}

A Frame represents a page or an iframe. The frame tree can be explored starting from the Page.main_frame() method.

Tree Traversal:

• Use child_frames() to get a list of all subframes within a frame.
• Use parent_frame() to get the parent frame (returns None for the main frame or detached frames).
• Use frame_element() to get the ElementHandle of the <iframe> or <frame> element that corresponds to this frame.

Lifecycle Events: Frames are managed via events dispatched on the Page object:

• frame_attached: Fired when a frame is attached to the page.
• frame_navigated: Fired when the frame commits navigation to a different URL.
• frame_detached: Fired when the frame is removed from the page.

// Example: Dumping the frame tree
async fn dump_frame_tree(frame: Frame, indent: &str) {
    println!("{}{}", indent, frame.url().unwrap());
    for child in frame.child_frames().unwrap() {
        dump_frame_tree(child, &format!("{}{}  ", indent, " ")).await;
    }
}

When a page sends a request for a network resource, Playwright emits a specific sequence of events on the Page object:

1. event: Page.request: Emitted when the request is first issued by the page.
2. event: Page.response: Emitted when the response status and headers are received.
3. event: Page.requestFinished: Emitted when the response body is fully downloaded and the request is complete.

Error Handling & Redirects:

• If a request fails, Playwright emits event: Page.requestFailed instead of requestfinished (and potentially instead of response).
• HTTP Errors: Responses with HTTP error codes (like 404 or 503) are considered successful from an HTTP standpoint; they will trigger the requestfinished event.
• Redirects: If a request receives a redirect response, the request is considered successfully finished (requestfinished), and a new request is issued to the redirected URL.