Thirtyfour

https://github.com/stevepryde/thirtyfour
Admin
Thirtyfour is a Rust library that provides a WebDriver client for browser automation and interaction...
Tokens:30,996
Snippets:382
Trust Score:8.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Quick Start: Basic CDP Commands

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/cdp/overview.md

Demonstrates how to initialize a WebDriver session and use basic CDP commands like getting browser version, emulating network conditions, and clearing the browser cache.

```rust
use thirtyfour::cdp::domains::network::{ConnectionType, NetworkConditions};
use thirtyfour::prelude::*; 

#[tokio::main]
async fn main() -> WebDriverResult<()> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

    // Domain-grouped typed methods.
    let info = driver.cdp().browser().get_version().await?;
    println!("Chrome: {}", info.product);

    // Throttle the network like Chrome DevTools' "Slow 3G".
    driver.cdp().network().emulate_network_conditions(NetworkConditions {
        offline: false,
        latency: 200,
        download_throughput: 256 * 1024,
        upload_throughput: 64 * 1024,
        connection_type: Some(ConnectionType::Cellular3G),
    }).await?;

    driver.cdp().network().clear_browser_cache().await?;

    driver.quit().await
}
```

--------------------------------

### Quick Start with WebDriver BiDi

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/bidi/overview.md

This example demonstrates how to enable BiDi, connect to the WebSocket, subscribe to load events, navigate to a URL, and print the loaded URL. It uses `DesiredCapabilities::chrome()` and `enable_bidi()` to set the `webSocketUrl: true` capability.

```rust
use thirtyfour::bidi::events::Load;
use thirtyfour::prelude::*;
use futures_util::StreamExt;

#[tokio::main(flavor = "multi_thread")]
async fn main() -> WebDriverResult<()> {
    let mut caps = DesiredCapabilities::chrome();
    caps.enable_bidi()?;             // <-- the W3C `webSocketUrl: true` opt-in.
    let driver = WebDriver::managed(caps).await?;

    // Lazy-connect the BiDi WebSocket on first use; cached afterwards.
    let bidi = driver.bidi().await?;

    let status = bidi.session().status().await?;
    println!("driver ready: {}", status.ready);

    // Pick the active browsing context.
    let context = bidi.browsing_context().top_level().await?;

    // Subscribe to load events and navigate. The typed `subscribe::<E>()`
    // call sends `session.subscribe` for us automatically; when the stream
    // drops, `session.unsubscribe` is sent in the background.
    let mut loads = bidi.subscribe::<Load>().await?;
    bidi.browsing_context().navigate(context.clone(), "https://example.com", None).await?;

    if let Some(load) = loads.next().await {
        println!("loaded: {}", load.url);
    }

    driver.quit().await
}
```

--------------------------------

### Running Selenium Example

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/tools/selenium.md

Execute the Selenium example provided with the library. Ensure a Selenium server is running before execution.

```bash
cargo run --example selenium_example
```

--------------------------------

### Basic Managed WebDriver Session

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/manager.md

Demonstrates the simplest way to start a managed WebDriver session for Chrome. The manager downloads the appropriate chromedriver if not found.

```rust
use thirtyfour::prelude::*;

#[tokio::main]
async fn main() -> WebDriverResult<()> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;
    driver.goto("https://www.rust-lang.org/").await?;
    driver.quit().await?;
    Ok(())
}
```

--------------------------------

### Running Selenium Server with Docker

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/tools/selenium.md

Start a Selenium standalone Chrome server using Docker. This command maps ports and mounts /dev/shm for browser session stability.

```bash
docker run --rm -d -p 4444:4444 -p 5900:5900 --name selenium-server -v /dev/shm:/dev/shm selenium/standalone-chrome:4.1.0-20211123
```

--------------------------------

### Browser Automation Script

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/first-code.md

A complete example of navigating to Wikipedia, searching for a term, and verifying the page title.

```rust
use std::error::Error;

use thirtyfour::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

    // Navigate to https://wikipedia.org.
    driver.goto("https://wikipedia.org").await?;
    let elem_form = driver
        .query(By::Id("search-form"))
        .desc("Wikipedia search form")
        .single()
        .await?;

    // Querying from an element scopes the search to its subtree.
    let elem_text = elem_form
        .query(By::Id("searchInput"))
        .desc("Wikipedia search input")
        .single()
        .await?;

    // Type in the search terms.
    elem_text.send_keys("selenium").await?;

    // Click the search button.
    let elem_button = elem_form
        .query(By::Css("button[type='submit']"))
        .desc("Wikipedia search button")
        .single()
        .await?;
    elem_button.click().await?;

    // Wait for the unique article heading before checking the title.
    driver
        .query(By::ClassName("firstHeading"))
        .desc("Wikipedia article heading")
        .single()
        .await?;
    assert_eq!(driver.title().await?, "Selenium - Wikipedia");

    // Always explicitly close the browser.
    driver.quit().await?;

    Ok(())
}
```

--------------------------------

### Configure Component Resolver Attributes

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/components.md

Examples of using the #[by(...)] attribute with various selectors, cardinality modes, and query options for component fields.

```rust
type LinkListResolver = ElementResolver<Vec<WebElement>>;

// Use the first match if there are several.
#[by(id = "search-input", first)]
input: ElementResolver<WebElement>,

// All <li> elements; empty list is fine.
#[by(tag = "li", allow_empty)]
items: ElementResolver<Vec<WebElement>>,

// Wait up to 60 seconds, polling every second, with a friendly description.
#[by(css = ".loading-spinner", description = "loading spinner",
     wait(timeout_ms = 60_000, interval_ms = 1_000))]
spinner: ElementResolver<WebElement>,

// A custom alias that contains ElementResolver<Vec<WebElement>>.
#[by(partial_link = "Guide", multi, allow_empty)]
guide_links: LinkListResolver,
```

--------------------------------

### Connect to Manual WebDriver

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/appendix/manual-webdriver.md

Connect to a manually started WebDriver instance by providing its URL and desired capabilities. Ensure the WebDriver binary is running and accessible at the specified address.

```rust
use thirtyfour::prelude::*;

#[tokio::main]
async fn main() -> WebDriverResult<()> {
    let caps = DesiredCapabilities::chrome();
    let driver = WebDriver::new("http://localhost:9515", caps).await?;
    driver.goto("https://www.rust-lang.org/").await?;
    driver.quit().await?;
    Ok(())
}
```

--------------------------------

### Define a search form HTML structure

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/components.md

The target HTML structure for the search form component example.

```html
<form id="search-form">
    <input type="text" id="search-input" />
    <button type="submit" data-testid="search-submit">Search</button>
</form>
```

--------------------------------

### Testid Selector Example

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/first-code.md

Demonstrates using stable data-testid attributes for element selection.

```rust
let save_button = driver
    .query(By::Testid("settings-save"))
    .desc("settings save button")
    .single()
    .await?;
```

--------------------------------

### Initialize Project

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/first-code.md

Commands to create a new Rust binary project and navigate into the directory.

```bash
cargo new --bin my-automation-project
cd my-automation-project
```

--------------------------------

### Implement a starter browser test

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/ai-quickstart.md

A template for a browser test using managed WebDriver and testid-based element queries.

```rust
use thirtyfour::{
    prelude::*,
    testing::{BrowserTestError, run_browser_test},
};

#[tokio::test]
async fn saves_profile_settings() -> Result<(), BrowserTestError> {
    let mut caps = DesiredCapabilities::chrome();
    caps.set_headless()?;
    run_browser_test(WebDriver::managed(caps), |driver| async move {
        driver.goto("https://example.test/settings").await?;

        let form = driver
            .query(By::Testid("profile-settings"))
            .desc("profile settings form")
            .single()
            .await?;

        form.query(By::Testid("display-name"))
            .desc("display name input")
            .single()
            .await?
            .send_keys("Ada")
            .await?;

        let save_button = form
            .query(By::Testid("save-profile"))
            .desc("save profile button")
            .single()
            .await?;
        save_button.click_when_ready().await?;

        // Assert the user-visible outcome. This query polls until the saved
        // state appears, so it replaces a brittle fixed sleep.
        driver
            .query(By::Testid("settings-status"))
            .with_text("Saved")
            .and_displayed()
            .desc("saved settings status")
            .single()
            .await?;

        Ok(())
    })
    .await
}
```

--------------------------------

### Run Project

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/first-code.md

Command to execute the automation script.

```bash
cargo run
```

--------------------------------

### Run Unit and Doc Tests

Source: https://github.com/stevepryde/thirtyfour/blob/main/CLAUDE.md

Execute fast unit tests for the thirtyfour crate or run documentation tests to ensure internal links are valid.

```bash
cargo test -p thirtyfour --lib
```

```bash
cargo test -p thirtyfour --doc
```

--------------------------------

### Query a nested element

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/explaining-the-code.md

Perform a scoped query starting from a parent element to find a child element.

```rust
    let elem_text = elem_form
        .query(By::Id("searchInput"))
        .desc("Wikipedia search input")
        .single()
        .await?;
```

--------------------------------

### Run Basic Integration Tests

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/contributing/testing.md

Execute the default integration tests for the thirtyfour crate. This command will automatically download and manage the necessary WebDriver for Chrome.

```bash
cargo test
```

--------------------------------

### Resolve WebElement to CDP Handles

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/cdp/overview.md

Use `cdp_backend_node_id` to get a stable `BackendNodeId` for DOM-related CDP calls, bridging WebDriver elements with CDP inspection capabilities.

```rust
use thirtyfour::cdp::domains::dom::GetBoxModel;

let elem = driver.find(By::Css("button.submit")).await?;
let backend_id = elem.cdp_backend_node_id().await?;

let box_model = driver.cdp().send(GetBoxModel {
    backend_node_id: Some(backend_id),
    ..Default::default()
}).await?;
println!("box model: {:?}", box_model.model);
```

--------------------------------

### Pre-push Checklist Commands

Source: https://github.com/stevepryde/thirtyfour/blob/main/CLAUDE.md

Run these commands to ensure code quality and documentation before pushing. They check formatting, documentation links, and general code style.

```bash
cargo fmt --check                                # honors rustfmt.toml (max_width=100, use_small_heuristics=Off)
cargo doc --no-deps --all-features               # rustdoc::all is warn-level — broken intra-doc links matter
cargo clippy --all-features --all-targets        # default lints, no -D warnings (yet) but stay clean
```

```bash
cargo fmt && cargo clippy --all-features --all-targets && cargo doc --no-deps --all-features
```

--------------------------------

### Run an asynchronous browser automation session

Source: https://github.com/stevepryde/thirtyfour/blob/main/thirtyfour/README.md

Demonstrates initializing a Chrome session, navigating to a URL, interacting with elements using the query interface, and closing the browser.

```rust
use thirtyfour::prelude::*;

#[tokio::main]
async fn main() -> WebDriverResult<()> {
     let caps = DesiredCapabilities::chrome();
     let driver = WebDriver::managed(caps).await?;

     // Navigate to https://wikipedia.org.
     driver.goto("https://wikipedia.org").await?;
     let elem_form = driver
         .query(By::Id("search-form"))
         .desc("Wikipedia search form")
         .single()
         .await?;

     // Querying from an element scopes the search to its subtree.
     let elem_text = elem_form
         .query(By::Id("searchInput"))
         .desc("Wikipedia search input")
         .single()
         .await?;

     // Type in the search terms.
     elem_text.send_keys("selenium").await?;

     // Click the search button.
     let elem_button = elem_form
         .query(By::Css("button[type='submit']"))
         .desc("Wikipedia search button")
         .single()
         .await?;
     elem_button.click().await?;

     // Wait for the unique article heading before checking the title.
     driver
         .query(By::ClassName("firstHeading"))
         .desc("Wikipedia article heading")
         .single()
         .await?;
     assert_eq!(driver.title().await?, "Selenium - Wikipedia");

     // Always explicitly close the browser.
     driver.quit().await?;

     Ok(())
}
```

--------------------------------

### CapabilitiesHelper Trait Update

Source: https://github.com/stevepryde/thirtyfour/blob/main/MIGRATION.md

The CapabilitiesHelper trait now has a blanket impl on AsRef<Capabilities> + AsMut<Capabilities>. Accessor methods are renamed to match the inherent API on Capabilities (e.g., _get to get). Custom capability wrappers should implement AsRef/AsMut instead of the old hook methods.

```rust
impl AsRef<Capabilities> for MyCaps {
    fn as_ref(&self) -> &Capabilities { &self.inner }
}
impl AsMut<Capabilities> for MyCaps {
    fn as_mut(&mut self) -> &mut Capabilities { &mut self.inner }
}
```

--------------------------------

### Run Doc Tests

Source: https://github.com/stevepryde/thirtyfour/blob/main/AGENTS.md

Execute documentation tests for the thirtyfour crate. These tests are rarely problematic but are inexpensive to run.

```bash
cargo test -p thirtyfour --doc
```

--------------------------------

### Locate and interact with ready elements

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/tools/selenium-playwright.md

Use query filters like and_clickable to ensure an element is ready before performing an action.

```rust
# use thirtyfour::prelude::*;
# async fn example(driver: &WebDriver) -> WebDriverResult<()> {
let save = driver
    .query(By::Testid("settings-save"))
    .and_clickable()
    .desc("settings save button")
    .single()
    .await?;
save.click().await?;
# Ok(())
# }
```

--------------------------------

### Customizing Driver Version and Source

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/manager.md

Shows how to customize the webdriver download using chained methods on the builder returned by WebDriver::managed(). Options include matching local browser versions, fetching the latest stable, pinning an exact version, reading from capabilities, or specifying a local driver binary path.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::manager::BrowserKind;
# async fn run() -> WebDriverResult<()> {
let caps = DesiredCapabilities::chrome();

// Default: match the locally-installed browser.
let driver = WebDriver::managed(caps.clone()).await?;

// Latest stable from upstream metadata.
let driver = WebDriver::managed(caps.clone()).latest().await?;

// Pin a specific version (full or major-only for Chrome/Edge).
let driver = WebDriver::managed(caps.clone()).exact("126").await?;

// Read `browserVersion` from the capabilities object.
let driver = WebDriver::managed(caps.clone()).from_caps().await?;

// Skip the download/cache flow entirely — use an already-installed
// driver binary at this path. See "Using A Pre-Installed Driver" below.
let driver = WebDriver::managed(caps)
    .driver_binary(BrowserKind::Chrome, "/usr/local/bin/chromedriver")
    .await?;
# Ok(())
# }
```

--------------------------------

### Navigate to a URL

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/explaining-the-code.md

Direct the browser to a specific web address.

```rust
    driver.goto("https://wikipedia.org").await?;
```

--------------------------------

### Instantiate and use the Component

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/components.md

Convert a WebElement into the SearchForm component and invoke its methods.

```rust
let form_el = driver.query(By::Id("search-form")).single().await?;
let form: SearchForm = form_el.into();         // From<WebElement> is derived.
form.search("Selenium").await?;
```

--------------------------------

### Use resolution macros

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/components.md

Demonstrates using the resolve! and resolve_present! macros to simplify element resolution.

```rust
use thirtyfour::{resolve, resolve_present};

let elem = resolve!(self.input);            // self.input.resolve().await?
let elem = resolve_present!(self.input);    // self.input.resolve_present().await?
```

--------------------------------

### Configure Dependencies

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/first-code.md

Required dependencies for Cargo.toml to enable thirtyfour and the tokio runtime.

```toml
[dependencies]
thirtyfour = "THIRTYFOUR_CRATE_VERSION"
tokio = { version = "1", features = ["full"] }
```

--------------------------------

### Perform element operations with ElementResolver

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/components.md

Demonstrates using clear, send_keys, and click_when_ready directly on an ElementResolver.

```rust
self.email.clear().await?;
self.email.send_keys("ada@example.test").await?;
self.submit.click_when_ready().await?;
```

--------------------------------

### Subscribe To A BiDi Load Event

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/recipes/browser-protocols.md

Requires the bidi feature and futures-util. enable_bidi() must be called on capabilities to request the WebSocket URL.

```toml
[dependencies]
futures-util = "0.3"
thirtyfour = { version = "THIRTYFOUR_CRATE_VERSION", features = ["bidi"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread", "time"] }
```

```rust
use std::time::Duration;
use futures_util::StreamExt;
use thirtyfour::bidi::events::Load;
use thirtyfour::prelude::*;

#[tokio::test]
async fn observes_a_page_load() -> WebDriverResult<()> {
    let mut caps = DesiredCapabilities::chrome();
    caps.enable_bidi()?;
    let driver = WebDriver::managed(caps).await?;

    let test_result: WebDriverResult<()> = async {
        let bidi = driver.bidi().await?;
        let mut loads = bidi.subscribe::<Load>().await?;
        let context = bidi.browsing_context().top_level().await?;

        bidi.browsing_context()
            .navigate(context, "https://example.test/dashboard", None)
            .await?;
        let load = tokio::time::timeout(Duration::from_secs(10), loads.next())
            .await
            .map_err(|_| WebDriverError::Timeout("BiDi load event timed out".into()))?
            .ok_or_else(|| WebDriverError::FatalError("BiDi event stream closed".into()))?;
        println!("loaded: {}", load.url);

        // Dropping the last typed stream schedules a best-effort unsubscribe.
        drop(loads);
        Ok(())
    }
    .await;

    let quit_result = driver.quit().await;
    test_result?;
    quit_result
}
```

--------------------------------

### Run Integration Tests with Firefox

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/contributing/testing.md

Execute the integration tests for the thirtyfour crate, specifically targeting Firefox. Set the THIRTYFOUR_BROWSER environment variable to 'firefox' before running the tests.

```bash
THIRTYFOUR_BROWSER=firefox cargo test
```

--------------------------------

### Run Fast Unit Tests

Source: https://github.com/stevepryde/thirtyfour/blob/main/AGENTS.md

Execute fast unit tests for the thirtyfour crate. These tests are designed to run quickly on every code change.

```bash
cargo test -p thirtyfour --lib
```

--------------------------------

### Click element when ready

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/waiting.md

Use click_when_ready() to combine waiting for clickability and performing the click action on a resolved element.

```rust
# use thirtyfour::prelude::*;
# async fn submit(save: WebElement) -> WebDriverResult<()> {
save.click_when_ready().await?;
# Ok(())
# }
```

--------------------------------

### Use Pre-Installed Driver with WebDriverManager

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/manager.md

Configure the manager to use a specific pre-installed driver binary instead of downloading it. This is useful for CI environments where drivers are managed externally.

```rust
# use thirtyfour::prelude::*
# use thirtyfour::manager::{WebDriverManager, BrowserKind};
# async fn run() -> WebDriverResult<()>
{
let manager = WebDriverManager::builder()
    .driver_binary(BrowserKind::Chrome, "/usr/local/bin/chromedriver")
    .build();
let driver = manager.launch(DesiredCapabilities::chrome()).await?;
Ok(())
}
```

--------------------------------

### Scoped Subscription using Subscribe Command

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/bidi/events.md

Shows how to use the explicit `session.send(Subscribe { ... })` command for events scoped to a specific browsing context. This method requires manual subscription and is an alternative to the auto-subscribe path.

```rust
# use thirtyfour::prelude::*;
# async fn run(bidi: thirtyfour::bidi::BiDi) -> WebDriverResult<()> {
use thirtyfour::bidi::modules::session::Subscribe;

let context = bidi.browsing_context().top_level().await?;

// Wire-level subscribe scoped to one tab. Then open the local stream
// to read it (the typed subscribe also bumps the global refcount, so
// `unsubscribe` won't fire mid-test if you mix them — but the cleanest
// pattern is to pick one approach per stream).
bidi.send(Subscribe {
    events: vec!["browsingContext.load".into()],
    contexts: vec![context],
    user_contexts: vec![],
}).await?;
let mut raw = bidi.subscribe_raw();
# Ok(())
# }
```

--------------------------------

### Enable BiDi Feature in Cargo.toml

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/bidi/overview.md

To use WebDriver BiDi, you need to enable the `bidi` feature for the thirtyfour crate in your `Cargo.toml` file.

```toml
[dependencies]
thirtyfour = { version = "THIRTYFOUR_CRATE_VERSION", features = ["bidi"] }
```

--------------------------------

### Typed Subscription to LogEntryAdded Events

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/bidi/events.md

Demonstrates how to subscribe to LogEntryAdded events using the typed `bidi.subscribe::<E>()` method. This automatically handles wire-level subscription and unsubscription. It navigates to a page that logs messages and then processes the received log entries.

```rust
use futures_util::StreamExt;
use thirtyfour::bidi::events::LogEntryAdded;
use thirtyfour::bidi::modules::log::LogLevel;
use thirtyfour::prelude::*;

# async fn run(driver: WebDriver) -> WebDriverResult<()> {
let bidi = driver.bidi().await?;

// Auto-sends `session.subscribe`.
let mut events = bidi.subscribe::<LogEntryAdded>().await?;

let context = bidi.browsing_context().top_level().await?;
bidi.browsing_context()
    .navigate(
        context,
        "data:text/html,<script>console.log('hi');console.warn('warn')</script>",
        None,
    )
    .await?;

while let Some(entry) = events.next().await {
    let level = match entry.level {
        LogLevel::Debug => "DEBUG",
        LogLevel::Info  => "INFO",
        LogLevel::Warn  => "WARN",
        LogLevel::Error => "ERROR",
        LogLevel::Unknown(ref s) => s.as_str(),
    };
    println!("[{level}] {}", entry.text.as_deref().unwrap_or(""));
}
# Ok(())
# }
```

--------------------------------

### Perform element lookup across frameworks

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/tools/selenium-playwright.md

Comparison of element lookup patterns in Selenium, Playwright, and thirtyfour.

```python
submit = driver.find_element(By.CSS_SELECTOR, "[data-testid='checkout-submit']")
```

```typescript
const submit = page.getByTestId("checkout-submit");
```

```rust
# use thirtyfour::prelude::*;
# async fn example(driver: &WebDriver) -> WebDriverResult<()> {
let submit = driver
    .query(By::Testid("checkout-submit"))
    .and_displayed()
    .desc("checkout submit button")
    .single()
    .await?;
# Ok(())
# }
```

--------------------------------

### Search Flow Implementation in Rust

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/recipes/forms-and-content.md

Uses thirtyfour to navigate to a page, interact with a search form, and verify the presence of specific results. Note that first() is used to find the first matching element in a list.

```rust
use thirtyfour::prelude::*;

#[tokio::test]
async fn searches_the_catalogue() -> WebDriverResult<()> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

    let test_result: WebDriverResult<()> = async {
        driver.goto("https://example.test/catalogue").await?;
        let form = driver
            .query(By::Testid("catalogue-search"))
            .desc("catalogue search form")
            .single()
            .await?;

        form.query(By::Testid("search-input"))
            .desc("catalogue search input")
            .single()
            .await?
            .send_keys("webdriver")
            .await?;
        let submit = form
            .query(By::Css("button[type='submit']"))
            .desc("catalogue search button")
            .single()
            .await?;
        submit.wait_until().clickable().await?;
        submit.click().await?;

        let results = driver
            .query(By::Testid("search-results"))
            .desc("catalogue search results")
            .single()
            .await?;
        results
            .query(By::Testid("result-title"))
            .with_text("Thirtyfour browser automation")
            .and_displayed()
            .desc("matching catalogue result title")
            .first()
            .await?;
        Ok(())
    }
    .await;

    let quit_result = driver.quit().await;
    test_result?;
    quit_result
}
```

--------------------------------

### Raw Event Stream Subscription

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/bidi/events.md

Demonstrates subscribing to a raw event stream using `bidi.subscribe_raw()`. This provides a firehose of all events delivered on the connection without filtering or deserialization, useful for debugging. It requires explicit subscription to event types beforehand.

```rust
use futures_util::StreamExt;
# use thirtyfour::prelude::*;
# async fn run(bidi: thirtyfour::bidi::BiDi) -> WebDriverResult<()> {
bidi.session().subscribe_many(["network".into(), "browsingContext".into()]).await?;
let mut all = bidi.subscribe_raw();
while let Some(event) = all.next().await {
    println!("{}: {}", event.method, event.params);
}
# Ok(())
# }
```

--------------------------------

### Send Raw BiDi Commands

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/bidi/overview.md

Executes raw BiDi commands using send_raw. Useful for commands not yet curated in the library. Accepts any serializable type for parameters.

```rust
# use thirtyfour::prelude::*;
# async fn run(bidi: thirtyfour::bidi::BiDi) -> WebDriverResult<()> {
// No-arg command:
let res = bidi.send_raw("session.status", ()).await?;
println!("{res}");

// With params:
bidi.send_raw(
    "browsingContext.activate",
    serde_json::json!({ "context": "abc" }),
).await?;
# Ok(())
# }
```

--------------------------------

### Sharing a WebDriver Manager Across Sessions

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/manager.md

Illustrates how to create a single WebDriverManager instance and use it to launch multiple independent WebDriver sessions. This is useful for reusing the manager and its spawned driver subprocesses across different parts of an application.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::manager::WebDriverManager;
# async fn run() -> WebDriverResult<()> {
let manager = WebDriverManager::builder().latest().build();

// One manager, multiple browsers.
let chrome  = manager.launch(DesiredCapabilities::chrome()).await?;
let firefox = manager.launch(DesiredCapabilities::firefox()).await?;
# Ok(())
# }
```

--------------------------------

### Thirtyfour Automation Checklist

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/reliable-tests.md

A set of guidelines for coding agents to ensure reliable WebDriver automation.

```text
- Use WebDriver::managed for local browsers; use WebDriver::new or builder only
  when connecting to a remote Selenium or Grid endpoint.
- Use query() for normal lookup. Use find() only for an intentional one-shot lookup.
- End unique queries with single(), and add desc(...) to important queries.
- Prefer By::Testid or another stable app-owned selector. Avoid generated classes,
  DOM-position chains, and XPath when stable CSS can express the target.
- Never use a fixed sleep for page readiness. Wait with query() or wait_until().
- Scope queries through a container element; use Components for repeated UI areas.
- Prefer run_browser_test(...) in tests; otherwise explicitly call
  driver.quit().await? when the session is finished.
- On failure, capture bounded diagnostics before cleanup with
  FailureArtifactCollector rather than dumping unbounded page source.
- Do not share one WebDriver session across independent concurrent flows. A shared
  WebDriverManager may launch separate sessions for parallel tests.
- Keep CDP and BiDi code isolated from portable WebDriver flows. Gate optional
  cdp-events and bidi APIs with their Cargo features, and opt BiDi sessions in.
```

--------------------------------

### Connect to a remote Selenium Grid

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/tools/selenium-playwright.md

Use WebDriver::builder to connect to an externally managed Selenium Grid endpoint.

```rust
# use thirtyfour::prelude::*;
# async fn example() -> WebDriverResult<()> {
let driver = WebDriver::builder(
    "http://selenium-grid:4444",
    DesiredCapabilities::chrome(),
)
.await?;
driver.quit().await?;
# Ok(())
# }
```

--------------------------------

### Migrate from ChromeDevTools to WebDriver::cdp

Source: https://github.com/stevepryde/thirtyfour/blob/main/MIGRATION.md

Compares the old method of executing CDP commands using `ChromeDevTools` with the new, preferred method using `WebDriver::cdp`.

```rust
// Before:
use thirtyfour::extensions::cdp::ChromeDevTools;
let dev = ChromeDevTools::new(driver.handle.clone());
let v = dev.execute_cdp("Browser.getVersion").await?;
let ua = v["userAgent"].as_str().unwrap();
```

```rust
// After:
let info = driver.cdp().browser().get_version().await?;
let ua = info.user_agent;
```

--------------------------------

### Attach descriptive labels to queries

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/queries.md

Use the desc() method to provide human-readable context for timeout errors during element selection.

```rust
let cart = driver
    .query(By::Css("[data-cart-count]"))
    .desc("shopping cart badge")
    .first()
    .await?;
```

--------------------------------

### Wait for element and verify title

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/explaining-the-code.md

Uses a query to wait for a specific element to appear before asserting the page title.

```rust
driver
    .query(By::ClassName("firstHeading"))
    .desc("Wikipedia article heading")
    .single()
    .await?;
assert_eq!(driver.title().await?, "Selenium - Wikipedia");
```

--------------------------------

### Untyped CDP Command Execution

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/cdp/overview.md

Shows how to send raw, untyped CDP commands using the `send_raw` method for commands not directly exposed as typed methods. This requires knowledge of CDP method names and parameter structures.

```rust
# use thirtyfour::prelude::*;

```

--------------------------------

### Subscribe to All Raw CDP Events

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/cdp/events.md

Subscribe to all raw CDP events on a session using `CdpSession::subscribe_all`. This is useful for observing child sessions or events not yet curated.

```rust
use futures_util::StreamExt;
# use thirtyfour::prelude::*;
async fn run(driver: WebDriver) -> WebDriverResult<()> {
let session = driver.cdp().connect().await?;
let mut all = session.subscribe_all();
while let Some(raw) = all.next().await {
    println!("[{{:?}}] {{}}: {{}}", raw.session_id, raw.method, raw.params);
}
# driver.quit().await
}
```

--------------------------------

### Run CDP Integration Tests

Source: https://github.com/stevepryde/thirtyfour/blob/main/CLAUDE.md

Execute integration tests for typed CDP commands and events. These tests require the 'manager-tests' feature and specific configurations for CDP events.

```bash
cargo test -p thirtyfour --features manager-tests --test cdp_typed -- --test-threads=1
```

```bash
cargo test -p thirtyfour --features manager-tests,cdp-events --test cdp_events -- --test-threads=1
```

--------------------------------

### Establish CDP Session

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/cdp/events.md

Connect to the browser's DevTools port to establish a CDP session. This session can be used to send commands and subscribe to events.

```rust
use thirtyfour::prelude::*;
async fn run() -> WebDriverResult<()> {
let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;
let session = driver.cdp().connect().await?;
println!("attached as session {:?}", session.session_id());
# driver.quit().await
}
```

--------------------------------

### Implement Page Objects as Components

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/tools/selenium-playwright.md

Define components using the Component derive macro and ElementResolver to manage selectors and user-intent methods.

```rust
use thirtyfour::prelude::*;

#[derive(Debug, Clone, Component)]
struct LoginForm {
    base: WebElement,
    #[by(testid = "login-email")]
    email: ElementResolver<WebElement>,
    #[by(testid = "login-password")]
    password: ElementResolver<WebElement>,
    #[by(testid = "login-submit")]
    submit: ElementResolver<WebElement>,
}

impl LoginForm {
    async fn sign_in(&self, email: &str, password: &str) -> WebDriverResult<()> {
        self.email.resolve_present().await?.send_keys(email).await?;
        self.password
            .resolve_present()
            .await?
            .send_keys(password)
            .await?;

        let submit = self.submit.resolve_present().await?;
        submit.wait_until().clickable().await?;
        submit.click().await
    }
}
```

--------------------------------

### Common CDP Event Imports

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/cdp/events.md

Import commonly used CDP event types from `thirtyfour::cdp::events` for convenience. Note that some domains like 'fetch' and 'target' require manual enabling.

```rust
use thirtyfour::cdp::events::{
    RequestWillBeSent,
    ResponseReceived,
    LoadingFinished,
    LoadingFailed,
    LifecycleEvent,
    FrameNavigated,
    LoadEventFired,
    ConsoleApiCalled,
    ExceptionThrown,
    LogEntryAdded,
    RequestPaused,                         // Fetch — manual enable required
    AttachedToTarget, DetachedFromTarget,  // Target — manual enable required
};

```

--------------------------------

### WebDriver Construction: Builder API

Source: https://github.com/stevepryde/thirtyfour/blob/main/MIGRATION.md

Use WebDriver::builder() for constructing WebDriver instances instead of new_with_config or new_with_config_and_client. The builder returns a WebDriverBuilder that implements IntoFuture for awaiting the session. Custom HttpClient is now supplied via .client() on the builder.

```rust
use thirtyfour::common::config::WebDriverConfig;
use std::time::Duration;

// Before:
// let config = WebDriverConfig::builder()
//     .reqwest_timeout(Duration::from_secs(30))
//     .user_agent("my-app/1.0")
//     .build()?;
// let driver = WebDriver::new_with_config("http://localhost:4444", caps, config).await?;

// After:
let driver = WebDriver::builder("http://localhost:4444", caps)
    .request_timeout(Duration::from_secs(30))
    .user_agent("my-app/1.0")
    .await?;
```

--------------------------------

### Capabilities Newtype and Set Method

Source: https://github.com/stevepryde/thirtyfour/blob/main/MIGRATION.md

Capabilities is now a newtype, replacing direct Map manipulation with methods like set(). Use caps.set(key, value)? instead of caps.insert(key, value) for setting capabilities. The wire format remains unchanged.

```rust
use serde_json::json;

// Before:
// let mut caps = Capabilities::new();
// caps.insert("browserName".to_string(), json!("chrome"));

// After:
let mut caps = Capabilities::new();
caps.set("browserName", "chrome")?;
```

--------------------------------

### Run CDP Event Subscription Tests

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/contributing/testing.md

Execute tests for CDP event subscription. This requires both the 'manager-tests' and 'cdp-events' cargo features and sets the test threads to 1.

```bash
cargo test -p thirtyfour --features manager-tests,cdp-events --test cdp_events -- --test-threads=1
```

--------------------------------

### Interact with an iframe in Rust

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/recipes/browser-contexts.md

Use enter_frame() to switch the driver context to an iframe and enter_default_frame() to return to the main document. Since there is no automatic frame guard, ensure the default frame is restored even if inner interactions fail.

```rust
use thirtyfour::prelude::*;

#[tokio::test]
async fn submits_embedded_checkout() -> WebDriverResult<()> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

    let test_result: WebDriverResult<()> = async {
        driver.goto("https://example.test/checkout").await?;
        driver
            .query(By::Testid("payment-frame"))
            .desc("payment iframe")
            .single()
            .await?
            .enter_frame()
            .await?;

        let frame_result: WebDriverResult<()> = async {
            let pay = driver
                .query(By::Testid("pay-now"))
                .desc("pay now button inside payment iframe")
                .single()
                .await?;
            pay.wait_until().clickable().await?;
            pay.click().await?;
            Ok(())
        }
        .await;

        // Frame switching has no guard, so restore the outer context even if
        // the interaction inside the frame fails.
        let restore_result = driver.enter_default_frame().await;
        frame_result?;
        restore_result?;
        driver
            .query(By::Testid("payment-status"))
            .with_text("Payment complete")
            .and_displayed()
            .desc("completed payment status")
            .single()
            .await?;
        Ok(())
    }
    .await;

    let quit_result = driver.quit().await;
    test_result?;
    quit_result
}
```

--------------------------------

### Upload a file in Rust

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/recipes/browser-contexts.md

Upload files by sending an absolute path to an <input type="file"> element. Ensure the path is accessible to the machine running the browser driver.

```rust
use thirtyfour::prelude::*;

#[tokio::test]
async fn uploads_an_avatar() -> WebDriverResult<()> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

    let test_result: WebDriverResult<()> = async {
        driver.goto("https://example.test/profile").await?;
        let input = driver
            .query(By::Testid("avatar-file"))
            .desc("avatar file input")
            .single()
            .await?;

        input.send_keys("/absolute/path/to/avatar.png").await?;
        let upload = driver
            .query(By::Testid("upload-avatar"))
            .desc("upload avatar button")
            .single()
            .await?;
        upload.wait_until().clickable().await?;
        upload.click().await?;

        driver
            .query(By::Testid("avatar-status"))
            .with_text("Upload complete")
            .and_displayed()
            .desc("completed avatar upload status")
            .single()
            .await?;
        Ok(())
    }
    .await;

    let quit_result = driver.quit().await;
    test_result?;
    quit_result
}
```

--------------------------------

### Run ElementQuery Filter Predicates Tests

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/contributing/testing.md

Execute tests for ElementQuery filter predicates. This requires the 'manager-tests' cargo feature and sets the test threads to 1.

```bash
cargo test -p thirtyfour --features manager-tests --test query_filters -- --test-threads=1
```

--------------------------------

### Initialize Managed WebDriver

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/explaining-the-code.md

Initializes a managed Chrome WebDriver session, which automatically handles driver binary downloading, process spawning, and session cleanup.

```rust
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;
```

--------------------------------

### Add ThirtyFour Dependency to Cargo.toml

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/installation.md

Add the thirtyfour crate to your project's dependencies in Cargo.toml. Replace THIRTYFOUR_CRATE_VERSION with the actual version number.

```toml
[dependencies]
thirtyfour = "THIRTYFOUR_CRATE_VERSION"
```

--------------------------------

### Record Chromium Browser and Driver Logs in Rust

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/recipes/diagnostics.md

Configures logging preferences and uses a polling loop to retrieve asynchronous browser logs. Requires the manager feature for driver-process log subscriptions.

```rust
use std::time::Duration;
use tokio::time::{Instant, sleep};
use thirtyfour::{LoggingPrefsLogLevel, prelude::*};

#[tokio::test]
async fn records_chromium_logs() -> WebDriverResult<()> {
    let mut caps = DesiredCapabilities::chrome();
    caps.set_browser_log_level(LoggingPrefsLogLevel::All)?;
    let driver = WebDriver::managed(caps)
        .on_driver_log(|entry| eprintln!("chromedriver: {}", entry.line))
        .await?;

    let test_result: WebDriverResult<()> = async {
        driver
            .goto("data:text/html,<script>console.error('checkout failed')</script>")
            .await?;

        // Log delivery is asynchronous and each call drains the buffer, so
        // accumulate entries until the expected marker arrives or times out.
        let deadline = Instant::now() + Duration::from_secs(5);
        let mut entries = Vec::new();
        loop {
            entries.extend(driver.browser_log().await?);
            if entries.iter().any(|entry| entry.message.contains("checkout failed")) {
                break;
            }
            if Instant::now() >= deadline {
                return Err(WebDriverError::Timeout("browser log marker did not arrive".into()));
            }
            sleep(Duration::from_millis(100)).await;
        }

        for entry in entries {
            println!("[{}] {}", entry.level, entry.message);
        }
        Ok(())
    }
    .await;

    let quit_result = driver.quit().await;
    test_result?;
    quit_result
}
```

--------------------------------

### Send Raw CDP Commands

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/cdp/overview.md

Use `send_raw` to execute CDP commands without predefined structs. Pass parameters as serializable types like JSON values or empty tuples.

```rust
let info = driver.cdp().send_raw("Browser.getVersion", ()).await?;
println!("user agent: {}", info["userAgent"]);

driver.cdp().send_raw("Page.navigate", serde_json::json!({ "url": "https://example.com" })).await?;
```

--------------------------------

### Submit a Login Form in Rust

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/recipes/forms-and-content.md

Uses data-testid hooks to scope form interactions and waits for the final state change to confirm successful login.

```rust
use thirtyfour::prelude::*;

#[tokio::test]
async fn logs_in() -> WebDriverResult<()> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

    let test_result: WebDriverResult<()> = async {
        driver.goto("https://example.test/login").await?;
        let form = driver
            .query(By::Testid("login-form"))
            .desc("login form")
            .single()
            .await?;

        form.query(By::Testid("email"))
            .desc("email input")
            .single()
            .await?
            .send_keys("ada@example.test")
            .await?;
        form.query(By::Testid("password"))
            .desc("password input")
            .single()
            .await?
            .send_keys("correct horse battery staple")
            .await?;

        let submit = form
            .query(By::Testid("login-submit"))
            .desc("login button")
            .single()
            .await?;
        submit.wait_until().clickable().await?;
        submit.click().await?;

        driver
            .query(By::Testid("account-heading"))
            .with_text("Welcome, Ada")
            .and_displayed()
            .desc("signed-in account heading")
            .single()
            .await?;
        Ok(())
    }
    .await;

    let quit_result = driver.quit().await;
    test_result?;
    quit_result
}
```

--------------------------------

### Text, Class, Attribute, and Property Waits

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/waiting.md

Methods to wait for specific content, class, attribute, or property matches using Needle patterns.

```APIDOC
## Content and Attribute Waits

### Description
These methods wait for an element's text, class, attribute, or property to match a provided `Needle` (exact string or `StringMatch`).

### Methods
- `.has_text(needle)` / `.lacks_text(needle)`
- `.has_class(name)` / `.lacks_class(name)`
- `.has_value(needle)` / `.lacks_value(needle)`
- `.has_attribute(name, needle)` / `.lacks_attribute(name, needle)`
- `.has_property(name, needle)` / `.lacks_property(name, needle)`
- `.has_css_property(name, needle)` / `.lacks_css_property(name, needle)`

### Usage Example
```rust
use thirtyfour::stringmatch::StringMatchable;

elem.wait_until()
    .has_text("Order received".match_partial().case_insensitive())
    .await?;
```
```

--------------------------------

### Set Emulation Overrides

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/bidi/overview.md

Sets geolocation, timezone, and locale overrides using the emulation module. Pass None to clear an override. Driver support varies.

```rust
use thirtyfour::bidi::modules::emulation::GeolocationCoordinates;
# use thirtyfour::prelude::*;
# async fn run(bidi: thirtyfour::bidi::BiDi) -> WebDriverResult<()> {
bidi.emulation()
    .set_geolocation_override(Some(GeolocationCoordinates {
        latitude: -33.8688,
        longitude: 151.2093,
        accuracy: Some(50.0),
        altitude: None,
        altitude_accuracy: None,
        heading: None,
        speed: None,
    }))
    .await?;

bidi.emulation().set_timezone_override(Some("Australia/Sydney".into())).await?;
bidi.emulation().set_locale_override(Some("en-AU".into())).await?;
# Ok(())
# }
```

--------------------------------

### Show Prompt Dialog

Source: https://github.com/stevepryde/thirtyfour/blob/main/thirtyfour/tests/test_html/sample_page.html

This JavaScript function displays a prompt dialog, allowing the user to input text. The input is then displayed in a designated element.

```javascript
function showPrompt() {
  document.getElementById("alert-answer").innerHTML = prompt("What is your name?");
}
```

--------------------------------

### Update Browser Option Insertion

Source: https://github.com/stevepryde/thirtyfour/blob/main/MIGRATION.md

Replaces `insert_browser_option` with `set_browser_option` for consistency. Behavior remains unchanged.

```rust
// Before:
caps.insert_browser_option("binary", "/path/to/chrome")?;

// After:
caps.set_browser_option("binary", "/path/to/chrome")?;
```

--------------------------------

### Resolution Macros

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/features/components.md

Macros provided to simplify resolution calls.

```APIDOC
## Resolution Macros

### Macros
- **resolve!(field)** - Equivalent to field.resolve().await?
- **resolve_present!(field)** - Equivalent to field.resolve_present().await?
```

--------------------------------

### Type text into an element

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/explaining-the-code.md

Sends keystrokes to a specified input element.

```rust
    elem_text.send_keys("selenium").await?;
```

--------------------------------

### Interact with an HTML modal in Rust

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/recipes/forms-and-content.md

Uses thirtyfour to locate a modal, verify its content, and handle closure by waiting for the element to become stale.

```rust
use thirtyfour::prelude::*;

#[tokio::test]
async fn confirms_account_deletion() -> WebDriverResult<()> {
    let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

    let test_result: WebDriverResult<()> = async {
        driver.goto("https://example.test/account").await?;
        let open = driver
            .query(By::Testid("delete-account"))
            .desc("delete account button")
            .single()
            .await?;
        open.wait_until().clickable().await?;
        open.click().await?;

        let modal = driver
            .query(By::Testid("delete-account-modal"))
            .and_displayed()
            .desc("delete account confirmation modal")
            .single()
            .await?;
        modal
            .query(By::Testid("modal-title"))
            .with_text("Delete account?")
            .desc("delete account modal title")
            .single()
            .await?;

        let cancel = modal
            .query(By::Testid("cancel-delete"))
            .desc("cancel account deletion button")
            .single()
            .await?;
        cancel.wait_until().clickable().await?;
        cancel.click().await?;
        modal.wait_until().stale().await?;
        Ok(())
    }
    .await;

    let quit_result = driver.quit().await;
    test_result?;
    quit_result
}
```

--------------------------------

### Click an element

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/explaining-the-code.md

Simulates a mouse click on the identified element.

```rust
    elem_button.click().await?;
```

--------------------------------

### Scope locators with WebElement queries

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/tools/selenium-playwright.md

Use a WebElement as a container to scope subsequent queries, mimicking Playwright's locator chaining behavior.

```rust
let dialog = driver
    .query(By::Testid("delete-dialog"))
    .and_displayed()
    .desc("delete confirmation dialog")
    .single()
    .await?;

dialog
    .query(By::Testid("confirm-delete"))
    .and_clickable()
    .desc("confirm delete button")
    .single()
    .await?
    .click()
    .await?;
```

--------------------------------

### Firefox Capabilities

Source: https://github.com/stevepryde/thirtyfour/blob/main/docs/src/getting-started/first-code.md

Snippet to modify the WebDriver configuration to use Firefox instead of Chrome.

```rust
let driver = WebDriver::managed(DesiredCapabilities::firefox()).await?;
```
Tokens:
Raw