Thirtyfour

https://docs.rs/thirtyfour/latest
Admin
Thirtyfour is a Selenium / WebDriver library for Rust, designed for automated website UI testing,...
Tokens:442,710
Snippets:4,181
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### FormComponent Implementation Example

Source: https://docs.rs/thirtyfour/latest/thirtyfour/components/derive.Component.html?search=

A complete example demonstrating the use of #[base], #[by] with various selectors, and custom resolvers within a struct.

```rust
async fn resolve_button(base: WebElement) -> WebDriverResult<WebElement> {
    base.query(By::ClassName("run-button")).and_displayed().first().await
}

#[derive(Debug, Clone, Component)]
pub struct FormComponent {
    #[base]
    root: WebElement,
    #[by(css = "input[type='checkbox']", first)]
    checkbox: ElementResolver<WebElement>,
    #[by(partial_link = "Help", description = "help link")]
    help: ElementResolver<WebElement>,
    #[by(tag = "label", allow_empty)]
    labels: ElementResolver<Vec<WebElement>>,
    #[by(custom = resolve_button)]
    button: ElementResolver<WebElement>,
    attempts: u32,
}

```

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

### start_tab_mirroring

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/cdp/devtools.rs.html?search=std%3A%3Avec

Starts tab mirroring on a target.

```APIDOC
## start_tab_mirroring(sink_name: &str)

### Description
Starts a tab mirroring session on the specified receiver target.

### Parameters
- **sink_name** (&str) - Required - The name of the sink to mirror to.
```

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

### Test setup error handling

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/testing/runner.rs.html?search=

Verifies that the body is not invoked if the setup phase fails.

```rust
#[tokio::test]
    async fn setup_error_does_not_invoke_body() {
        let body_invoked = Arc::new(AtomicBool::new(false));
        let invoked = Arc::clone(&body_invoked);

        let result = run_browser_test(
            async {
                Err::<WebDriver, _>(WebDriverError::SessionCreateError("setup failed".to_string()))
            },
            move |_| {
                invoked.store(true, Ordering::SeqCst);
                async { Ok::<(), BodyError>(()) }
            },
        )
        .await;

        assert!(matches!(result, Err(BrowserTestError::Setup(_))));
        assert!(!body_invoked.load(Ordering::SeqCst));
    }
```

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

### start_tab_mirroring

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/cdp/devtools.rs.html?search=u32+-%3E+bool

Starts tab mirroring on a specific sink.

```APIDOC
## start_tab_mirroring(&self, sink_name: &str) -> WebDriverResult<()>

### Description
Initiates a tab mirroring session on the specified receiver target.

### Parameters
- **sink_name** (&str) - Required - The name of the sink to mirror to.
```

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

### FirefoxCommand::InstallAddon

Source: https://docs.rs/thirtyfour/latest/thirtyfour/extensions/addons/firefox/enum.FirefoxCommand.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Installs a Firefox add-on from a specified path.

```APIDOC
## FirefoxCommand::InstallAddon

### Description
Installs the specified add-on into the Firefox session.

### Parameters
- **path** (String) - Required - Path to the add-on file.
- **temporary** (Option<bool>) - Optional - Set to true if the add-on should be installed as temporary.
```

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

### Creating a new window

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/switch_to.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of creating a new browser window.

```rust
```no_run
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
// Open a new window.
let handle = driver.new_window().await?;
#         driver.quit().await?;
#         Ok(())
#     })
# }
```
```

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

### install_addon

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/addons/firefox/firefoxtools.rs.html?search=

Installs a Firefox add-on from the specified path.

```APIDOC
## install_addon(path: &str, temporary: Option<bool>)

### Description
Installs a Firefox add-on from the provided file path. Optionally, the add-on can be installed temporarily.

### Parameters
- **path** (&str) - Required - The file path to the add-on.
- **temporary** (Option<bool>) - Optional - Whether to install the add-on temporarily.
```

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

### install_addon

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/addons/firefox/firefoxtools.rs.html?search=u32+-%3E+bool

Installs a Firefox add-on from the specified file path.

```APIDOC
## install_addon(path: &str, temporary: Option<bool>)

### Description
Installs a Firefox add-on from the provided file path. An optional boolean can be specified to indicate if the installation should be temporary.

### Parameters
- **path** (&str) - Required - The file path to the add-on.
- **temporary** (Option<bool>) - Optional - Whether the add-on installation is temporary.

### Returns
- **WebDriverResult<()>** - Returns an empty result on success or a WebDriver error.
```

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

### start_session

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/create/fn.start_session.html?search=std%3A%3Avec

Starts a new WebDriver session with the provided configuration and capabilities.

```APIDOC
## Function: start_session

### Description
Starts a new WebDriver session, returning the session id and the capabilities JSON that was received back from the server.

### Signature
`pub async fn start_session(http_client: &dyn HttpClient, server_url: &Url, config: &WebDriverConfig, capabilities: Capabilities) -> WebDriverResult<StartedSession>`

### Parameters
- **http_client** (&dyn HttpClient) - The HTTP client implementation to use for the request.
- **server_url** (&Url) - The URL of the WebDriver server.
- **config** (&WebDriverConfig) - The configuration settings for the WebDriver.
- **capabilities** (Capabilities) - The desired capabilities for the session.

### Returns
- **WebDriverResult<StartedSession>** - A result containing the started session details or an error.
```

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

### windows

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/handle/struct.SessionHandle.html?search=u32+-%3E+bool

Get all window handles for the current session.

```APIDOC
## pub async fn windows(&self) -> WebDriverResult<Vec<WindowHandle>>

### Description
Get all window handles for the current session.
```

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

### Example search queries

Source: https://docs.rs/thirtyfour/latest/thirtyfour/extensions/addons/firefox/struct.FirefoxTools.html?search=

Common search patterns for finding types and functions in the documentation.

```text
std::vec
u32 -> bool
Option<T>, (T -> U) -> Option<U>
```

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

### Create new ChromeDevTools instance

Source: https://docs.rs/thirtyfour/latest/thirtyfour/extensions/cdp/struct.ChromeDevTools.html?search=

Example of initializing a new ChromeDevTools instance.

```rust
use thirtyfour::extensions::cdp::ChromeDevTools;
block_on(async {
let dev_tools = ChromeDevTools::new(driver.handle().clone());
```

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

### Creating a new tab

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/switch_to.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of creating a new tab in the current window.

```rust
```no_run
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
// Open a new tab in the current window.
let handle = driver.new_tab().await?;
#         driver.quit().await?;
#         Ok(())
#     })
# }
```
```

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

### Log.enable

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/domains/log/index.html?search=

Enables the log domain to start receiving log entries.

```APIDOC
## Log.enable

### Description
Enables the log domain to start receiving log entries.
```

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

### Initialize WebDriver with DesiredCapabilities

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/common/capabilities/desiredcapabilities.rs.html?search=

Example of creating a Chrome capability set and using it to initialize a new WebDriver instance.

```rust
use thirtyfour::{DesiredCapabilities, WebDriver};
let caps = DesiredCapabilities::chrome();
let driver = WebDriver::new("http://localhost:4444", caps);
```

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

### FirefoxTools::install_addon

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/addons/firefox/firefoxtools.rs.html

Installs a Firefox add-on from the specified path.

```APIDOC
## FirefoxTools::install_addon(path: &str, temporary: Option<bool>)

### Description
Installs a Firefox add-on from a local file path. Optionally marks the installation as temporary.

### Parameters
- **path** (&str) - Required - The file system path to the add-on.
- **temporary** (Option<bool>) - Optional - Whether the add-on should be installed temporarily.
```

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

### FirefoxCommand::InstallAddon

Source: https://docs.rs/thirtyfour/latest/thirtyfour/extensions/addons/firefox/enum.FirefoxCommand.html?search=

Installs a Firefox add-on from a specified path. You can optionally mark the add-on as temporary.

```APIDOC
## InstallAddon

### Description
Installs the specified add-on into the Firefox browser session.

### Fields
- **path** (String) - The file system path to the add-on.
- **temporary** (Option<bool>) - If true, the add-on is installed as a temporary add-on.
```

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

### Clicking Elements

Source: https://docs.rs/thirtyfour/latest/thirtyfour/action_chain/struct.ActionChain.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of clicking and holding elements using ActionChain.

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().move_to_element_center(&elem).click().perform().await?;
```

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().click_element(&elem).perform().await?;
```

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().move_to_element_center(&elem).click_and_hold().perform().await?;
```

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().click_and_hold_element(&elem).perform().await?;
```

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

### BrowserCapabilitiesHelper Implementations

Source: https://docs.rs/thirtyfour/latest/thirtyfour/common/capabilities/desiredcapabilities/trait.BrowserCapabilitiesHelper.html

Examples of how different browser capability structs implement the KEY constant for their respective browser options.

```rust
impl BrowserCapabilitiesHelper for ChromeCapabilities {
    const KEY: &'static str = "goog:chromeOptions"
}
```

```rust
impl BrowserCapabilitiesHelper for ChromiumCapabilities {
    const KEY: &'static str = "goog:chromeOptions"
}
```

```rust
impl BrowserCapabilitiesHelper for EdgeCapabilities {
    const KEY: &'static str = "ms:edgeOptions"
}
```

```rust
impl BrowserCapabilitiesHelper for FirefoxCapabilities {
    const KEY: &'static str = "moz:firefoxOptions"
}
```

```rust
impl BrowserCapabilitiesHelper for InternetExplorerCapabilities {
    const KEY: &'static str = "se:ieOptions"
}
```

```rust
impl BrowserCapabilitiesHelper for OperaCapabilities {
    const KEY: &'static str = "operaOptions"
}
```

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

### start_session function signature

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/create/fn.start_session.html

The function signature for starting a new WebDriver session.

```rust
pub async fn start_session(
    http_client: &dyn HttpClient,
    server_url: &Url,
    config: &WebDriverConfig,
    capabilities: Capabilities,
) -> WebDriverResult<StartedSession>
```

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

### start_session

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/create/fn.start_session.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a new WebDriver session, returning the session ID and the capabilities JSON received from the server.

```APIDOC
## Function: start_session

### Description
Starts a new WebDriver session, returning the session id and the capabilities JSON that was received back from the server.

### Signature
`pub async fn start_session(http_client: &dyn HttpClient, server_url: &Url, config: &WebDriverConfig, capabilities: Capabilities) -> WebDriverResult<StartedSession>`

### Parameters
- **http_client** (&dyn HttpClient) - The HTTP client used to communicate with the WebDriver server.
- **server_url** (&Url) - The URL of the WebDriver server.
- **config** (&WebDriverConfig) - The configuration settings for the WebDriver.
- **capabilities** (Capabilities) - The desired capabilities for the session.

### Returns
- **WebDriverResult<StartedSession>** - A result containing the started session details or an error.
```

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

### XPath Scoping Example

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/common/command.rs.html

Demonstrates the difference between document-rooted and relative XPath searches when querying from a WebElement.

```rust
# use thirtyfour::prelude::*;
# async fn _scope(parent: WebElement) -> WebDriverResult<()> {
// Wrong — searches the whole document, may match elements outside `parent`.
let _ = parent.find(By::XPath("//div[@class='child']")).await?;
// Right — searches only inside `parent`.
let _ = parent.find(By::XPath(".//div[@class='child']")).await?;
# Ok(()) }
```

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

### Define HTML structure for components

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/components/mod.rs.html?search=

Example HTML structure used to demonstrate component wrapping.

```html
<div id="checkbox-section">
    <label>
        <input type="checkbox" id="checkbox-option-1" />
        Option 1
    </label>

    <label>
        <input type="checkbox" id="checkbox-disabled" disabled />
        Option 2
    </label>

    <label>
        <input type="checkbox" id="checkbox-hidden" style="display: none;" />
        Option 3
    </label>
</div>
```

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

### start_session

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/create/fn.start_session.html

Starts a new WebDriver session using the provided HTTP client, server URL, configuration, and capabilities.

```APIDOC
## Function: start_session

### Description
Starts a new WebDriver session, returning the session id and the capabilities JSON that was received back from the server.

### Signature
`pub async fn start_session(http_client: &dyn HttpClient, server_url: &Url, config: &WebDriverConfig, capabilities: Capabilities) -> WebDriverResult<StartedSession>`

### Parameters
- **http_client** (&dyn HttpClient) - The HTTP client to use for the request.
- **server_url** (&Url) - The URL of the WebDriver server.
- **config** (&WebDriverConfig) - The configuration for the WebDriver.
- **capabilities** (Capabilities) - The desired capabilities for the session.

### Returns
- **WebDriverResult<StartedSession>** - A result containing the started session details or a WebDriver error.
```

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

### start_session

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/create/fn.start_session.html?search=u32+-%3E+bool

Starts a new WebDriver session using the provided HTTP client, server URL, configuration, and capabilities.

```APIDOC
## Function: start_session

### Description
Starts a new WebDriver session, returning the session id and the capabilities JSON that was received back from the server.

### Signature
`pub async fn start_session(http_client: &dyn HttpClient, server_url: &Url, config: &WebDriverConfig, capabilities: Capabilities) -> WebDriverResult<StartedSession>`

### Parameters
- **http_client** (&dyn HttpClient) - The HTTP client used to communicate with the WebDriver server.
- **server_url** (&Url) - The URL of the WebDriver server.
- **config** (&WebDriverConfig) - The configuration for the WebDriver session.
- **capabilities** (Capabilities) - The desired capabilities for the session.

### Returns
- **WebDriverResult<StartedSession>** - A result containing the started session details or an error.
```

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

### fn start(&self) -> Box<dyn ElementPoller + Send + Sync>

Source: https://docs.rs/thirtyfour/latest/thirtyfour/extensions/query/trait.IntoElementPoller.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a new poller instance. This method is called at the beginning of the polling loop to initialize the polling behavior.

```APIDOC
## fn start(&self) -> Box<dyn ElementPoller + Send + Sync>

### Description
Starts a new poller. This method is required to be implemented by any type that acts as an element poller factory.

### Returns
- **Box<dyn ElementPoller + Send + Sync>** - A boxed instance of an object implementing the ElementPoller trait, which is thread-safe.
```

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

### Construct and use a Component

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/components/mod.rs.html?search=

Shows how to instantiate a component from a WebElement and interact with its resolved elements.

```rust
let elem = driver.query(By::Id("checkbox-section")).await?;
let component = CheckboxSectionComponent::from(elem);

// Now you can get the checkbox components easily like this.
let checkboxes = component.boxes.resolve().await?;
for checkbox in checkboxes {
    checkbox.tick().await?;
}
```

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

### window

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/handle/struct.SessionHandle.html?search=u32+-%3E+bool

Get the current window handle.

```APIDOC
## pub async fn window(&self) -> WebDriverResult<WindowHandle>

### Description
Get the current window handle.
```

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

### DOM.resolveNode

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/cdp/domains/dom.rs.html

Get a RemoteObject handle for a node.

```APIDOC
## DOM.resolveNode

### Description
Resolves a DOM node to a RemoteObject handle.

### Parameters
- **node_id** (NodeId) - Optional - The node ID.
- **backend_node_id** (BackendNodeId) - Optional - The backend node ID.
- **object_group** (String) - Optional - The object group name.
- **execution_context_id** (ExecutionContextId) - Optional - The execution context ID.

### Response
- **object** (RemoteObject) - The JS object wrapper for the node.
```

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

### Initialize Test Driver Helpers

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/testing/runner.rs.html?search=

Helper functions to create a WebDriver instance with a recording client and configurable cleanup behavior.

```rust
fn test_driver(fail_first_delete: bool) -> (WebDriver, Arc<ClientState>) {
    test_driver_with_cleanup(fail_first_delete, false)
}

fn test_driver_with_cleanup(
    fail_first_delete: bool,
    panic_first_delete: bool,
) -> (WebDriver, Arc<ClientState>) {
    test_driver_with_guard(fail_first_delete, panic_first_delete, None)
}

fn test_driver_with_guard(
    fail_first_delete: bool,
    panic_first_delete: bool,
    driver_guard: Option<Arc<dyn crate::session::DriverGuard>>,
) -> (WebDriver, Arc<ClientState>) {
    let state = Arc::new(ClientState {
        delete_attempts: AtomicUsize::new(0),
        fail_first_delete: AtomicBool::new(fail_first_delete),
        panic_first_delete: AtomicBool::new(panic_first_delete),
    });
    let client: Arc<dyn HttpClient> = Arc::new(RecordingClient(Arc::clone(&state)));
    let handle = SessionHandle::new_with_config_guard_and_caps(
        client,
        "http://localhost:4444",
        SessionId::from("test-session"),
        WebDriverConfig::default(),
        driver_guard,
        Capabilities::new(),
    )
    .expect("valid test session");

    (
        WebDriver {
            handle: Arc::new(handle),
        },
        state,
    )
}
```

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

### fn start(&self) -> Box<dyn ElementPoller + Send + Sync>

Source: https://docs.rs/thirtyfour/latest/thirtyfour/extensions/query/trait.IntoElementPoller.html

The start method is required to be implemented by any type that implements IntoElementPoller. It returns a boxed instance of an ElementPoller that is both Send and Sync, intended to be used at the beginning of a polling loop.

```APIDOC
## fn start(&self) -> Box<dyn ElementPoller + Send + Sync>

### Description
Starts a new poller instance. This method is invoked at the beginning of a polling loop to provide the polling logic.

### Returns
- **Box<dyn ElementPoller + Send + Sync>** - A trait object representing the initialized poller.
```

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

### Result::is_err Implementation

Source: https://docs.rs/thirtyfour/latest/thirtyfour/error/type.WebDriverResult.html

Example of checking if a Result is Err.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

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

### Initialize and use a WebDriver session

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/web_driver.rs.html?search=

Demonstrates creating a new browser session, navigating to a URL, and ensuring the session is closed.

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

# fn main() -> anyhow::Result<()> {
#     block_on(async {
let caps = DesiredCapabilities::firefox();
let driver = WebDriver::new("http://localhost:4444", caps).await?;
driver.goto("https://www.rust-lang.org/").await?;
// Always remember to close the session.
driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### Result::is_ok Implementation

Source: https://docs.rs/thirtyfour/latest/thirtyfour/error/type.WebDriverResult.html

Example of checking if a Result is Ok.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

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

### Context and Double Clicking

Source: https://docs.rs/thirtyfour/latest/thirtyfour/action_chain/struct.ActionChain.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of right-clicking and double-clicking elements.

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().move_to_element_center(&elem).context_click().perform().await?;
```

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().context_click_element(&elem).perform().await?;
```

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().move_to_element_center(&elem).double_click().perform().await?;
```

```rust
let elem = driver.find(By::Id("button1")).await?;
driver.action_chain().double_click_element(&elem).perform().await?;
```

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

### Get Class Name

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/web_element.rs.html

Retrieves the class name for a WebElement.

```rust
let elem = driver.find(By::Id("button1")).await?;
let class_name: Option<String> = elem.class_name().await?;
```

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

### Get Targets

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/cdp/domains/target.rs.html?search=u32+-%3E+bool

Retrieves a list of all available targets and their metadata.

```rust
/// `Target.getTargets`.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTargets;
/// One entry returned by [`GetTargets`].
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TargetInfo {
    /// Target id.
    pub target_id: TargetId,
    /// Target type (e.g. `"page"`, `"iframe"`, `"worker"`).
    pub r#type: String,
    /// Title.
    pub title: String,
    /// URL.
    pub url: String,
    /// Whether the target is currently attached.
    pub attached: bool,
    /// Browser context id.
    pub browser_context_id: Option<BrowserContextId>,
    /// Opener id.
    pub opener_id: Option<TargetId>,
}
/// Response for [`GetTargets`].
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GetTargetsResult {
    /// All targets.
    pub target_infos: Vec<TargetInfo>,
}
impl CdpCommand for GetTargets {
    const METHOD: &'static str = "Target.getTargets";
    type Returns = GetTargetsResult;
}
```

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

### Retrieve all window handles

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/session/handle.rs.html?search=

Shows how to list all available window handles for the current session.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
assert_eq!(driver.windows().await?.len(), 1);
// Open a new tab.
driver.new_tab().await?;

// Get window handles and switch to the new tab.
let handles = driver.windows().await?;
assert_eq!(handles.len(), 2);
driver.switch_to_window(handles[1].clone()).await?;
#         driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### new_window

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/switch_to.rs.html

Creates and switches to a new browser window.

```APIDOC
## new_window()

### Description
Opens a new browser window and returns the handle for the newly created window.
```

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

### Key Action Source Implementation

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/common/action.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating a key action source and managing keyboard input events.

```rust
    /// Create a new Key action source.
    ///
    /// Duration represents the time before an action is executed.
    /// Defaults to 0ms
    pub fn new(name: &str, duration: Option<Duration>) -> Self {
        let duration = match duration {
            Some(duration) => {
                let millis = duration.as_millis();
                u64::try_from(millis).ok().unwrap_or(u64::MAX)
            }
            None => 0,
        };

        ActionSource {
            id: name.to_owned(),
            action_type: String::from("key"),
            parameters: None,
            actions: Vec::new(),
            duration,
        }
    }

    /// Add a Key Down action.
    pub fn key_down(&mut self, value: char) {
        self.add_action(KeyAction::KeyDown {
            value,
        });
    }

    /// Add a Key Up action.
    pub fn key_up(&mut self, value: char) {
        self.add_action(KeyAction::KeyUp {
            value,
        });
    }

    /// Send multiple keys as a string of Key Up and Key Down actions.
    pub fn send_keys(&mut self, text: TypingData) {
        for c in text.as_vec() {
            self.key_down(c);
            self.key_up(c);
        }
    }
}
```

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

### Result::flatten Usage

Source: https://docs.rs/thirtyfour/latest/thirtyfour/error/type.WebDriverResult.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of flattening nested Result types.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

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

### Implement CdpEvent for RequestWillBeSent

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Network.requestWillBeSent event.

```rust
impl CdpEvent for RequestWillBeSent
{
    const METHOD: &'static str = "Network.requestWillBeSent";
    const ENABLE: Option<&'static str>
}
```

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

### Manage browser windows and tabs

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/session/handle.rs.html?search=

Demonstrates retrieving the current window handle, opening new tabs, and switching between them.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
// Get the current window handle.
let handle = driver.window().await?;

// Open a new tab.
driver.new_tab().await?;

// Get window handles and switch to the new tab.
let handles = driver.windows().await?;
driver.switch_to_window(handles[1].clone()).await?;

// We are now controlling the new tab.
driver.goto("https://www.rust-lang.org/").await?;
assert_ne!(driver.window().await?, handle);

// Switch back to original tab.
driver.switch_to_window(handle.clone()).await?;
assert_eq!(driver.window().await?, handle);
#         driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### Implement CdpEvent for RequestPaused

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Fetch.requestPaused event.

```rust
impl CdpEvent for RequestPaused
{
    const METHOD: &'static str = "Fetch.requestPaused"
}
```

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

### enable

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/domains/log/struct.LogDomain.html

Enables log domain, sends the entries collected so far to the client, and starts sending additional logging entries.

```APIDOC
## pub async fn enable(&self) -> WebDriverResult<()>

### Description
Enables the log domain to start receiving log entries.

### Signature
`pub async fn enable(&self) -> WebDriverResult<()>`
```

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

### Implement CdpEvent for LoadingFinished

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Network.loadingFinished event.

```rust
impl CdpEvent for LoadingFinished
{
    const METHOD: &'static str = "Network.loadingFinished";
    const ENABLE: Option<&'static str>
}
```

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

### Create a new window

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/switch_to.rs.html

Use new_window to open a new browser window and return its handle.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
// Open a new window.
let handle = driver.new_window().await?;
#         driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### Manage browser windows

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/handle/struct.SessionHandle.html?search=u32+-%3E+bool

Handle window switching and state management.

```rust
// Get the current window handle.
let handle = driver.window().await?;

// Open a new tab.
driver.new_tab().await?;

// Get window handles and switch to the new tab.
let handles = driver.windows().await?;
driver.switch_to_window(handles[1].clone()).await?;

// We are now controlling the new tab.
driver.goto("https://www.rust-lang.org/").await?;
assert_ne!(driver.window().await?, handle);

// Switch back to original tab.
driver.switch_to_window(handle.clone()).await?;
assert_eq!(driver.window().await?, handle);
```

```rust
assert_eq!(driver.windows().await?.len(), 1);
// Open a new tab.
driver.new_tab().await?;

// Get window handles and switch to the new tab.
let handles = driver.windows().await?;
assert_eq!(handles.len(), 2);
driver.switch_to_window(handles[1].clone()).await?;
```

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

### Implement CdpEvent for LoadEventFired

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Page.loadEventFired event.

```rust
impl CdpEvent for LoadEventFired
{
    const METHOD: &'static str = "Page.loadEventFired";
    const ENABLE: Option<&'static str>
}
```

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

### Implement CdpEvent for LifecycleEvent

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Page.lifecycleEvent event.

```rust
impl CdpEvent for LifecycleEvent
{
    const METHOD: &'static str = "Page.lifecycleEvent";
    const ENABLE: Option<&'static str>
}
```

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

### goto

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/session/handle.rs.html?search=

Navigates the browser to the specified URL.

```APIDOC
## goto

### Description
Navigates the browser to the specified URL. If the URL is relative, it attempts to prepend 'https://'.

### Signature
`pub async fn goto(&self, url: impl IntoArcStr) -> WebDriverResult<()>`
```

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

### Implement CdpEvent for FrameNavigated

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Page.frameNavigated event.

```rust
impl CdpEvent for FrameNavigated
{
    const METHOD: &'static str = "Page.frameNavigated";
    const ENABLE: Option<&'static str>
}
```

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

### Implement CdpEvent for EntryAdded

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Log.entryAdded event.

```rust
impl CdpEvent for EntryAdded
{
    const METHOD: &'static str = "Log.entryAdded";
    const ENABLE: Option<&'static str>
}
```

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

### Implement a Mock HttpClient for Configuration Testing

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/session/handle.rs.html?search=

Defines a dummy HttpClient that panics if called, suitable for testing configuration logic without network interaction.

```rust
struct UnusedClient;

#[async_trait::async_trait]
impl HttpClient for UnusedClient {
    async fn send(&self, _: Request<Body<'_>>) -> WebDriverResult<Response<Bytes>> {
        unreachable!("configuration tests do not issue WebDriver commands")
    }

    async fn new(&self) -> Arc<dyn HttpClient> {
        Arc::new(Self)
    }
}
```

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

### Implement CdpEvent for ConsoleApiCalled

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/trait.CdpEvent.html

Example implementation of CdpEvent for the Runtime.consoleAPICalled event.

```rust
impl CdpEvent for ConsoleApiCalled
{
    const METHOD: &'static str = "Runtime.consoleAPICalled";
    const ENABLE: Option<&'static str>
}
```

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

### Runtime.enable

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/domains/runtime/struct.Enable.html?search=std%3A%3Avec

Enables the runtime domain. This command does not require any parameters and returns an empty response.

```APIDOC
## Runtime.enable

### Description
Enables the runtime domain, allowing the client to receive runtime events and interact with the runtime environment.

### Method
CDP Command

### Parameters
None

### Response
- **Returns** (Empty) - This command returns an empty object `{}` upon success.
```

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

### Create a new WebDriver instance

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/web_driver.rs.html?search=

Shows the basic instantiation of a WebDriver session using desired capabilities.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
let caps = DesiredCapabilities::firefox();
let driver = WebDriver::new("http://localhost:4444", caps).await?;
#         driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### Capabilities::new

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/common/capabilities/desiredcapabilities.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an empty Capabilities instance.

```APIDOC
## Capabilities::new()

### Description
Creates an empty `Capabilities` instance.

### Signature
`pub fn new() -> Self`
```

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

### Constructing a Managed WebDriver

Source: https://docs.rs/thirtyfour/latest/thirtyfour/struct.WebDriver.html

Demonstrates creating a WebDriver instance that automatically manages the driver subprocess lifecycle.

```rust
// Default (matches the locally-installed browser).
let driver = WebDriver::managed(DesiredCapabilities::chrome()).await?;

// Override the version inline using the same builder shape used by
// `WebDriverManager::builder()`.
let driver = WebDriver::managed(caps).latest().await?;
```

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

### Get network conditions

Source: https://docs.rs/thirtyfour/latest/thirtyfour/extensions/cdp/struct.ChromeDevTools.html?search=

Retrieve current network conditions after setting them.

```rust
use thirtyfour::extensions::cdp::{ChromeDevTools, NetworkConditions};
// Create ChromeDevTools struct.
let dev_tools = ChromeDevTools::new(driver.handle().clone());

// First we need to set the network conditions.
let mut conditions = NetworkConditions::new();
conditions.download_throughput = 20;
dev_tools.set_network_conditions(&conditions).await?;

// Now we can get the network conditions.
let conditions_out = dev_tools.get_network_conditions().await?;
assert_eq!(conditions_out.download_throughput, conditions.download_throughput);
```

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

### Manage Windows

Source: https://docs.rs/thirtyfour/latest/thirtyfour/session/handle/struct.SessionHandle.html?search=

Methods for retrieving window handles, switching between tabs, and adjusting window state.

```rust
// Get the current window handle.
let handle = driver.window().await?;

// Open a new tab.
driver.new_tab().await?;

// Get window handles and switch to the new tab.
let handles = driver.windows().await?;
driver.switch_to_window(handles[1].clone()).await?;

// We are now controlling the new tab.
driver.goto("https://www.rust-lang.org/").await?;
assert_ne!(driver.window().await?, handle);

// Switch back to original tab.
driver.switch_to_window(handle.clone()).await?;
assert_eq!(driver.window().await?, handle);
```

```rust
assert_eq!(driver.windows().await?.len(), 1);
// Open a new tab.
driver.new_tab().await?;

// Get window handles and switch to the new tab.
let handles = driver.windows().await?;
assert_eq!(handles.len(), 2);
driver.switch_to_window(handles[1].clone()).await?;
```

```rust
driver.maximize_window().await?;
```

```rust
driver.minimize_window().await?;
```

```rust
driver.fullscreen_window().await?;
```

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

### Get parent element

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/web_element.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the parent element of the current WebElement.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
let elem = driver.find(By::Id("child")).await?;
let parent = elem.parent().await?;
#         driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### Retrieve WebElement Text

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/web_element.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the visible text content of a WebElement.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
let elem = driver.find(By::Id("button1")).await?;
let text = elem.text().await?;
assert_eq!(text, "Click Me");
#         driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### Result::transpose Usage

Source: https://docs.rs/thirtyfour/latest/thirtyfour/error/type.WebDriverResult.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of transposing a Result of an Option into an Option of a Result.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

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

### Switching to a named window

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/switch_to.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to switch back to a previously named window after opening a new tab.

```rust
```no_run
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
// Set main window name so we can switch back easily.
driver.set_window_name("mywindow").await?;

// Open a new tab.
driver.new_tab().await?;

// Get window handles and switch to the new tab.
let handles = driver.windows().await?;
driver.switch_to_window(handles[1].clone()).await?;

// We are now controlling the new tab.
assert_eq!(driver.title().await?, "");
driver.switch_to_named_window("mywindow").await?;

// We are now back in the original tab.
#         driver.quit().await?;
#         Ok(())
#     })
# }
```
```

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

### enable_bidi()

Source: https://docs.rs/thirtyfour/latest/thirtyfour/common/capabilities/chrome/struct.ChromeCapabilities.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Opts the session into WebDriver BiDi by setting the W3C webSocketUrl capability.

```APIDOC
## fn enable_bidi(&mut self) -> WebDriverResult<()>

### Description
Opt the session in to WebDriver BiDi by setting the W3C `webSocketUrl: true` capability.
```

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

### Build WebDriver Configuration

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/common/config.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Use the WebDriverConfigBuilder to construct a configuration instance with custom settings.

```rust
pub struct WebDriverConfigBuilder {
    keep_alive: bool,
    poller: Option<Arc<dyn IntoElementPoller + Send + Sync>>,
    user_agent: Option<WebDriverResult<HeaderValue>>,
    request_timeout: Duration,
}
```

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

### WebDriverManager::launch

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/manager/manager.rs.html

Spawns or reuses a driver and starts a new WebDriver session.

```APIDOC
## pub async fn launch(self: &Arc<Self>, capabilities: impl Into<Capabilities>) -> WebDriverResult<WebDriver>

### Description
Spawns or reuses the appropriate driver and starts a session. If a driver process for the same browser/version/host is already alive, it is reused.

### Parameters
- **capabilities** (impl Into<Capabilities>) - The browser capabilities to request for the session.

### Returns
- **WebDriverResult<WebDriver>** - A result containing the initialized WebDriver instance or an error.
```

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

### WebDriverManager::launch

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/manager/manager.rs.html?search=

Spawns or reuses a driver and starts a new WebDriver session.

```APIDOC
## pub async fn launch(self: &Arc<Self>, capabilities: impl Into<Capabilities>) -> WebDriverResult<WebDriver>

### Description
Spawns or reuses the appropriate driver and starts a session. If a driver process for the same browser/version/host is already alive, it is reused.

### Parameters
- **capabilities** (impl Into<Capabilities>) - Required - The capabilities to use for the session.

### Returns
- **WebDriverResult<WebDriver>** - A result containing the started WebDriver instance or an error.
```

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

### Get Response Body Command

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/cdp/domains/network.rs.html

Command to retrieve the body of a network request.

```rust
/// `Network.getResponseBody`.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetResponseBody {
    /// Identifier of the network request.
    pub request_id: RequestId,
}

/// Response for [`GetResponseBody`].
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseBody {
    /// Response body.
    pub body: String,
    /// True if `body` is base64-encoded.
    pub base64_encoded: bool,
}

impl CdpCommand for GetResponseBody {
    const METHOD: &'static str = "Network.getResponseBody";
    type Returns = ResponseBody;
}
```

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

### ChromiumCapabilities::new

Source: https://docs.rs/thirtyfour/latest/thirtyfour/common/capabilities/chromium/struct.ChromiumCapabilities.html

Creates a new instance of ChromiumCapabilities.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new ChromiumCapabilities struct for configuring browser options.
```

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

### Get Alert Text

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/alert.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the text content of the currently active alert.

```rust
# use thirtyfour::prelude::*;
# use thirtyfour::support::block_on;
#
# fn main() -> WebDriverResult<()> {
#     block_on(async {
#         let caps = DesiredCapabilities::chrome();
#         let driver = WebDriver::new("http://localhost:4444", caps).await?;
let text = driver.get_alert_text().await?;
#         driver.quit().await?;
#         Ok(())
#     })
# }
```

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

### ChromiumCapabilities::new

Source: https://docs.rs/thirtyfour/latest/thirtyfour/common/capabilities/chromium/struct.ChromiumCapabilities.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of ChromiumCapabilities.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new ChromiumCapabilities struct instance.

### Signature
`pub fn new() -> Self`
```

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

### ChromeCapabilities::new

Source: https://docs.rs/thirtyfour/latest/thirtyfour/common/capabilities/chrome/struct.ChromeCapabilities.html?search=std%3A%3Avec

Creates a new instance of ChromeCapabilities.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new ChromeCapabilities struct.
```

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

### Set Network Conditions

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/cdp/devtools.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of configuring network parameters via the ChromeDevTools struct.

```rust
use thirtyfour::extensions::cdp::{ChromeDevTools, NetworkConditions};

// Create ChromeDevTools struct.
let dev_tools = ChromeDevTools::new(driver.handle().clone());

// Now we can set the network conditions. You do not need to set all parameters.
```

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

### Manage Network Conditions

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/cdp/devtools.rs.html?search=u32+-%3E+bool

Examples for setting and retrieving network conditions via CDP.

```rust
// Create ChromeDevTools struct.
let dev_tools = ChromeDevTools::new(driver.handle().clone());

// First we need to set the network conditions.
let mut conditions = NetworkConditions::new();
conditions.download_throughput = 20;
dev_tools.set_network_conditions(&conditions).await?;

// Now we can get the network conditions.
let conditions_out = dev_tools.get_network_conditions().await?;
assert_eq!(conditions_out.download_throughput, conditions.download_throughput);
```

```rust
// Create ChromeDevTools struct.
let dev_tools = ChromeDevTools::new(driver.handle().clone());

// Now we can set the network conditions. You do not need to set all parameters.
```

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

### enable

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/domains/runtime/struct.RuntimeDomain.html?search=

Enables the Runtime domain for the current session.

```APIDOC
## pub async fn enable(&self) -> WebDriverResult<()>

### Description
Enables the Runtime domain, allowing the client to receive events and execute commands.

### Returns
- **WebDriverResult<()>** - Returns Ok if successful, or a WebDriver error.
```

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

### ElementQueryable Trait Implementation

Source: https://docs.rs/thirtyfour/latest/src/thirtyfour/extensions/query/element_query.rs.html?search=

Trait and implementations for starting element queries from WebElements or SessionHandles.

```rust
pub trait ElementQueryable {
    /// Start an element query using the specified selector.
    fn query(&self, by: By) -> ElementQuery;
}

impl ElementQueryable for WebElement {
    /// Return an ElementQuery instance for more executing powerful element queries.
    ///
    /// This uses the builder pattern to construct queries that will return one or
    /// more elements, depending on the method specified at the end of the chain.
    ///
    /// See [`ElementQuery`] for more documentation.
    fn query(&self, by: By) -> ElementQuery {
        ElementQuery::new(
            ElementQuerySource::Element(self.clone()),
            by,
            self.handle.config().poller.clone(),
        )
    }
}

impl ElementQueryable for Arc<SessionHandle> {
    /// Return an ElementQuery instance for more executing powerful element queries.
    ///
    /// This uses the builder pattern to construct queries that will return one or
    /// more elements, depending on the method specified at the end of the chain.
    ///
    /// See [`ElementQuery`] for more documentation.
    fn query(&self, by: By) -> ElementQuery {
        ElementQuery::new(
            ElementQuerySource::Driver(self.clone()),
            by,
            self.config().poller.clone(),
        )
    }
}
```

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

### enable

Source: https://docs.rs/thirtyfour/latest/thirtyfour/cdp/domains/runtime/struct.RuntimeDomain.html

Enables the runtime domain for the current session.

```APIDOC
## pub async fn enable(&self) -> WebDriverResult<()>

### Description
Enables the runtime domain for the current session, allowing for script evaluation and object management.

### Returns
- **WebDriverResult<()>** - Returns Ok if successful, or an error if the operation fails.
```
Tokens:
Raw