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
143
144
145
146
147
148
149
150
151
152
153
154
//! Powerful query interface featuring filtering and polling options. This is
//! the recommended way to find elements in `thirtyfour`.
//!
//! See examples for more details.
//!
//! ## Usage
//!
//! ### ElementQuery
//!
//! The `WebDriver::query()` and `WebElement::query()` methods work out-of-the-box with no
//! additional setup required.
//! However, you can customize some behaviour if needed.
//!
//! Now, using the query interface, you can do things like this:
//!
//! ```no_run
//! # use thirtyfour::prelude::*;
//! # use thirtyfour::support::block_on;
//! #
//! # fn main() -> WebDriverResult<()> {
//! # block_on(async {
//! # let caps = DesiredCapabilities::chrome();
//! # let mut driver = WebDriver::new("http://localhost:4444", caps).await?;
//! // This will only poll once and then return a bool immediately.
//! let is_found = driver
//! .query(By::Id("button1"))
//! .nowait()
//! .exists()
//! .await?;
//!
//! // This will poll until either branch matches at least one element.
//! // Only the first matched element will be returned.
//! let elem = driver
//! .query(By::Css("thiswont.match"))
//! .or(By::Id("button1"))
//! .first()
//! .await?;
//! # driver.quit().await?;
//! # Ok(())
//! # })
//! # }
//! ```
//!
//! This will execute both queries once per poll iteration and return the first one that matches.
//!
//! You can also filter on one or both query branches like this:
//!
//! ```no_run
//! # use thirtyfour::prelude::*;
//! # use thirtyfour::support::block_on;
//! use thirtyfour::stringmatch::StringMatch;
//! # use std::time::Duration;
//! #
//! # fn main() -> WebDriverResult<()> {
//! # block_on(async {
//! # let caps = DesiredCapabilities::chrome();
//! # let mut driver = WebDriver::new("http://localhost:4444", caps).await?;
//! let elem = driver
//! .query(By::Css("thiswont.match"))
//! .with_text("testing")
//! .or(By::Id("button1"))
//! .with_class(StringMatch::new("pure-button").word())
//! .and_enabled()
//! .first()
//! .await?;
//! # driver.quit().await?;
//! # Ok(())
//! # })
//! # }
//! ```
//!
//! Note the use of `StringMatch` to provide a partial (whole-word) match on the class name.
//! See the documentation for [StringMatch](https://crates.io/crates/stringmatch) for more info.
//!
//! **NOTE:** Each filter will trigger an additional request to the WebDriver server for every poll
//! iteration.
//! It is therefore strongly recommended to use `By::*` selectors to perform filtering,
//! if possible.
//! The `By::Css` and `By::XPath` selectors may be required for more complex
//! filters.
//!
//! To fetch all matching elements instead of just the first one, change `first()` to `all()`
//! and you'll get a Vec instead.
//! Note that `all()` will return only the elements from the query
//! branch that first matched something.
//! In the above example, if the
//! `(By::Css("branch.one")).with_text("testing")` branch returned at least one element, then only
//! those elements will be returned from an `all()` call even if the other branch has
//! matched something.
//! If you want to fetch all elements matched by all branches,
//! it's probably best to execute multiple queries.
//!
//! All timeout, interval and ElementPoller details can be overridden on a per-call basis if
//! desired.
//! See the [`ElementQuery`] documentation for more details.
//!
//! [`ElementQuery`]: ElementQuery
//!
//! ### ElementWaiter
//!
//! With `ElementWaiter` you can do things like this:
//! ```ignore
//! elem.wait_until().displayed().await?;
//! // You can optionally provide a nicer error message like this.
//! elem.wait_until().error("Timed out waiting for element to disappear").not_displayed().await?;
//!
//! elem.wait_until().enabled().await?;
//! elem.wait_until().clickable().await?;
//! ```
//!
//! And so on.
//! See the [`ElementWaiter`] docs for the full
//! list of predicates available.
//!
//! [`ElementWaiter`]: ElementWaiter
//!
//! `ElementWaiter` also allows the user of custom predicates that take a `&WebElement` argument
//! and return a `WebDriverResult<bool>`.
//!
//! A range of pre-defined predicates are also supplied for convenience in the
//! `thirtyfour::extensions::query::conditions` module.
//!
//! ```ignore
//! use thirtyfour_query::conditions;
//!
//! elem.wait_until().conditions(vec![
//! conditions::element_is_displayed(true),
//! conditions::element_is_clickable(true)
//! ]).await?;
//! ```
//! Take a look at the `conditions` module for the full list of predicates available.
//! NOTE: Predicates require you to specify whether errors should be ignored.
//!
//! These predicates (or your own) can also be supplied as filters to `ElementQuery`.
//!
//! ### ElementPoller
//!
//! The polling strategy can be customized by implementing both [`ElementPoller`]
//! and [`IntoElementPoller`].
//!
//! See [`ElementPollerWithTimeout`] for more details about the default polling behaviour.
//!
//! [`ElementPoller`]: ElementPoller
//! [`IntoElementPoller`]: IntoElementPoller
//! [`ElementPollerWithTimeout`]: ElementPollerWithTimeout
/// Predicates to use for element conditions.
pub use *;
pub use *;
pub use *;