thirtyfour 0.37.4

Thirtyfour is a Selenium / WebDriver library for Rust, for automated website UI testing. Tested on Chrome and Firefox, but any webdriver-capable browser should work.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

[![Crates.io](https://img.shields.io/crates/v/thirtyfour.svg)](https://crates.io/crates/thirtyfour)
[![docs.rs](https://docs.rs/thirtyfour/badge.svg)](https://docs.rs/thirtyfour)
[![Build Status](https://img.shields.io/github/actions/workflow/status/stevepryde/thirtyfour/test.yml?branch=main)](https://github.com/stevepryde/thirtyfour/actions)
[![code coverage](https://codecov.io/github/stevepryde/thirtyfour/graph/badge.svg?token=Z3GDO1EXCX)](https://codecov.io/github/stevepryde/thirtyfour)

# thirtyfour

Thirtyfour is a Selenium / WebDriver library for Rust, for automated website UI testing.

Documentation is available as the [Thirtyfour book](https://stevepryde.github.io/thirtyfour/),
[llms.txt](https://stevepryde.github.io/thirtyfour/llms.txt), and
[llms-full.txt](https://stevepryde.github.io/thirtyfour/llms-full.txt).
If you are porting existing automation, start with the
[Selenium and Playwright translation guide](https://stevepryde.github.io/thirtyfour/tools/selenium-playwright.html).

## Features

- All W3C WebDriver and WebElement methods supported
- Create new browser session directly via WebDriver (e.g. chromedriver)
- Create new browser session via Selenium Standalone or Grid
- Find elements (via all common selectors e.g. Testid, Id, Class, CSS, Tag, XPath)
- Send keys to elements, including key-combinations
- Execute Javascript
- Action Chains
- Get and set cookies
- Switch to frame/window/element/alert
- Shadow DOM support
- Alert support
- Capture / Save screenshot of browser or individual element as PNG
- Chrome DevTools Protocol (CDP) — typed commands plus optional WebSocket-based event subscription via the `cdp-events` feature
- WebDriver BiDi (W3C bidirectional protocol) — typed commands and event subscription cross-browser, opt-in via the `bidi` feature
- Powerful query interface (the recommended way to find elements) with explicit waits and various predicates
- Component Wrappers (similar to `Page Object Model`)
- Browser-test runner that attempts asynchronous cleanup on errors and panics

## Feature Flags

- `rustls-tls`: (Default) Use rustls to provide TLS support (via reqwest).
- `native-tls`: Use native TLS (via reqwest).
- `component`: (Default) Enable the `Component` derive macro (via
  thirtyfour_macros) and export `Component` / `ElementResolver` from the
  prelude.
- `cdp`: (Default) Typed Chrome DevTools Protocol commands.
- `cdp-events`: WebSocket-backed CDP event subscription.
- `bidi`: WebDriver BiDi (W3C) — typed commands and event subscription
  via `WebDriver::bidi()`. Opt in by calling `caps.enable_bidi()` before
  starting the session.

### Example (async):

To run this example:

    cargo run --example tokio_async

```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(())
}
```

For test functions, prefer
[`run_browser_test`](https://docs.rs/thirtyfour/latest/thirtyfour/testing/fn.run_browser_test.html).
It attempts `driver.quit().await` after successful tests, early error returns,
and panicking assertions, and preserves both errors when the test and cleanup
fail. Call `quit()` directly for application flows that do not use the runner.

### Prefer stable selectors

When you control the application under test, give important elements stable
`data-testid` hooks and select them with `By::Testid`:

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

Prefer app-owned test IDs first, then stable semantic CSS selectors. Match
visible text when the copy itself is part of the behavior you are testing, and
use XPath only when CSS cannot reasonably express the target. The Wikipedia
example above uses the stable selectors that third-party page actually exposes.

See the [Element Queries](https://stevepryde.github.io/thirtyfour/features/queries.html)
chapter for the full selector guidance.

## Minimum Supported Rust Version

Rust 1.88.

## LICENSE

This work is dual-licensed under MIT or Apache 2.0.
You can choose either license if you use this work.

See the NOTICE file for more details.

`SPDX-License-Identifier: MIT OR Apache-2.0`