-
-
Notifications
You must be signed in to change notification settings - Fork 8.2k
/
expected_conditions.py
555 lines (398 loc) · 17.2 KB
/
expected_conditions.py
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
# Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import re
from collections.abc import Iterable
from typing import Any
from typing import Callable
from typing import List
from typing import Literal
from typing import Tuple
from typing import TypeVar
from typing import Union
from selenium.common.exceptions import NoAlertPresentException
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoSuchFrameException
from selenium.common.exceptions import StaleElementReferenceException
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.alert import Alert
from selenium.webdriver.remote.webdriver import WebDriver
from selenium.webdriver.remote.webdriver import WebElement
"""
* Canned "Expected Conditions" which are generally useful within webdriver
* tests.
"""
D = TypeVar("D")
T = TypeVar("T")
WebDriverOrWebElement = Union[WebDriver, WebElement]
def title_is(title: str) -> Callable[[WebDriver], bool]:
"""An expectation for checking the title of a page.
title is the expected title, which must be an exact match returns
True if the title matches, false otherwise.
"""
def _predicate(driver: WebDriver):
return driver.title == title
return _predicate
def title_contains(title: str) -> Callable[[WebDriver], bool]:
"""An expectation for checking that the title contains a case-sensitive
substring.
title is the fragment of title expected returns True when the title
matches, False otherwise
"""
def _predicate(driver: WebDriver):
return title in driver.title
return _predicate
def presence_of_element_located(locator: Tuple[str, str]) -> Callable[[WebDriverOrWebElement], WebElement]:
"""An expectation for checking that an element is present on the DOM of a
page. This does not necessarily mean that the element is visible.
locator - used to find the element
returns the WebElement once it is located
"""
def _predicate(driver: WebDriverOrWebElement):
return driver.find_element(*locator)
return _predicate
def url_contains(url: str) -> Callable[[WebDriver], bool]:
"""An expectation for checking that the current url contains a case-
sensitive substring.
url is the fragment of url expected, returns True when the url
matches, False otherwise
"""
def _predicate(driver: WebDriver):
return url in driver.current_url
return _predicate
def url_matches(pattern: str) -> Callable[[WebDriver], bool]:
"""An expectation for checking the current url.
pattern is the expected pattern. This finds the first occurrence of
pattern in the current url and as such does not require an exact
full match.
"""
def _predicate(driver: WebDriver):
return re.search(pattern, driver.current_url) is not None
return _predicate
def url_to_be(url: str) -> Callable[[WebDriver], bool]:
"""An expectation for checking the current url.
url is the expected url, which must be an exact match returns True
if the url matches, false otherwise.
"""
def _predicate(driver: WebDriver):
return url == driver.current_url
return _predicate
def url_changes(url: str) -> Callable[[WebDriver], bool]:
"""An expectation for checking the current url.
url is the expected url, which must not be an exact match returns
True if the url is different, false otherwise.
"""
def _predicate(driver: WebDriver):
return url != driver.current_url
return _predicate
def visibility_of_element_located(
locator: Tuple[str, str]
) -> Callable[[WebDriverOrWebElement], Union[Literal[False], WebElement]]:
"""An expectation for checking that an element is present on the DOM of a
page and visible. Visibility means that the element is not only displayed
but also has a height and width that is greater than 0.
locator - used to find the element
returns the WebElement once it is located and visible
"""
def _predicate(driver: WebDriverOrWebElement):
try:
return _element_if_visible(driver.find_element(*locator))
except StaleElementReferenceException:
return False
return _predicate
def visibility_of(element: WebElement) -> Callable[[Any], Union[Literal[False], WebElement]]:
"""An expectation for checking that an element, known to be present on the
DOM of a page, is visible.
Visibility means that the element is not only displayed but also has
a height and width that is greater than 0. element is the WebElement
returns the (same) WebElement once it is visible
"""
def _predicate(_):
return _element_if_visible(element)
return _predicate
def _element_if_visible(element: WebElement, visibility: bool = True) -> Union[Literal[False], WebElement]:
return element if element.is_displayed() == visibility else False
def presence_of_all_elements_located(locator: Tuple[str, str]) -> Callable[[WebDriverOrWebElement], List[WebElement]]:
"""An expectation for checking that there is at least one element present
on a web page.
locator is used to find the element returns the list of WebElements
once they are located
"""
def _predicate(driver: WebDriverOrWebElement):
return driver.find_elements(*locator)
return _predicate
def visibility_of_any_elements_located(locator: Tuple[str, str]) -> Callable[[WebDriverOrWebElement], List[WebElement]]:
"""An expectation for checking that there is at least one element visible
on a web page.
locator is used to find the element returns the list of WebElements
once they are located
"""
def _predicate(driver: WebDriverOrWebElement):
return [element for element in driver.find_elements(*locator) if _element_if_visible(element)]
return _predicate
def visibility_of_all_elements_located(
locator: Tuple[str, str]
) -> Callable[[WebDriverOrWebElement], Union[List[WebElement], Literal[False]]]:
"""An expectation for checking that all elements are present on the DOM of
a page and visible. Visibility means that the elements are not only
displayed but also has a height and width that is greater than 0.
locator - used to find the elements
returns the list of WebElements once they are located and visible
"""
def _predicate(driver: WebDriverOrWebElement):
try:
elements = driver.find_elements(*locator)
for element in elements:
if _element_if_visible(element, visibility=False):
return False
return elements
except StaleElementReferenceException:
return False
return _predicate
def text_to_be_present_in_element(locator: Tuple[str, str], text_: str) -> Callable[[WebDriverOrWebElement], bool]:
"""An expectation for checking if the given text is present in the
specified element.
locator, text
"""
def _predicate(driver: WebDriverOrWebElement):
try:
element_text = driver.find_element(*locator).text
return text_ in element_text
except StaleElementReferenceException:
return False
return _predicate
def text_to_be_present_in_element_value(
locator: Tuple[str, str], text_: str
) -> Callable[[WebDriverOrWebElement], bool]:
"""An expectation for checking if the given text is present in the
element's value.
locator, text
"""
def _predicate(driver: WebDriverOrWebElement):
try:
element_text = driver.find_element(*locator).get_attribute("value")
return text_ in element_text
except StaleElementReferenceException:
return False
return _predicate
def text_to_be_present_in_element_attribute(
locator: Tuple[str, str], attribute_: str, text_: str
) -> Callable[[WebDriverOrWebElement], bool]:
"""An expectation for checking if the given text is present in the
element's attribute.
locator, attribute, text
"""
def _predicate(driver: WebDriverOrWebElement):
try:
element_text = driver.find_element(*locator).get_attribute(attribute_)
if element_text is None:
return False
return text_ in element_text
except StaleElementReferenceException:
return False
return _predicate
def frame_to_be_available_and_switch_to_it(locator: Union[Tuple[str, str], str]) -> Callable[[WebDriver], bool]:
"""An expectation for checking whether the given frame is available to
switch to.
If the frame is available it switches the given driver to the
specified frame.
"""
def _predicate(driver: WebDriver):
try:
if isinstance(locator, Iterable) and not isinstance(locator, str):
driver.switch_to.frame(driver.find_element(*locator))
else:
driver.switch_to.frame(locator)
return True
except NoSuchFrameException:
return False
return _predicate
def invisibility_of_element_located(
locator: Union[WebElement, Tuple[str, str]]
) -> Callable[[WebDriverOrWebElement], Union[WebElement, bool]]:
"""An Expectation for checking that an element is either invisible or not
present on the DOM.
locator used to find the element
"""
def _predicate(driver: WebDriverOrWebElement):
try:
target = locator
if not isinstance(target, WebElement):
target = driver.find_element(*target)
return _element_if_visible(target, visibility=False)
except (NoSuchElementException, StaleElementReferenceException):
# In the case of NoSuchElement, returns true because the element is
# not present in DOM. The try block checks if the element is present
# but is invisible.
# In the case of StaleElementReference, returns true because stale
# element reference implies that element is no longer visible.
return True
return _predicate
def invisibility_of_element(
element: Union[WebElement, Tuple[str, str]]
) -> Callable[[WebDriverOrWebElement], Union[WebElement, bool]]:
"""An Expectation for checking that an element is either invisible or not
present on the DOM.
element is either a locator (text) or an WebElement
"""
return invisibility_of_element_located(element)
def element_to_be_clickable(
mark: Union[WebElement, Tuple[str, str]]
) -> Callable[[WebDriverOrWebElement], Union[Literal[False], WebElement]]:
"""An Expectation for checking an element is visible and enabled such that
you can click it.
element is either a locator (text) or an WebElement
"""
# renamed argument to 'mark', to indicate that both locator
# and WebElement args are valid
def _predicate(driver: WebDriverOrWebElement):
target = mark
if not isinstance(target, WebElement): # if given locator instead of WebElement
target = driver.find_element(*target) # grab element at locator
element = visibility_of(target)(driver)
if element and element.is_enabled():
return element
return False
return _predicate
def staleness_of(element: WebElement) -> Callable[[Any], bool]:
"""Wait until an element is no longer attached to the DOM.
element is the element to wait for. returns False if the element is
still attached to the DOM, true otherwise.
"""
def _predicate(_):
try:
# Calling any method forces a staleness check
element.is_enabled()
return False
except StaleElementReferenceException:
return True
return _predicate
def element_to_be_selected(element: WebElement) -> Callable[[Any], bool]:
"""An expectation for checking the selection is selected.
element is WebElement object
"""
def _predicate(_):
return element.is_selected()
return _predicate
def element_located_to_be_selected(locator: Tuple[str, str]) -> Callable[[WebDriverOrWebElement], bool]:
"""An expectation for the element to be located is selected.
locator is a tuple of (by, path)
"""
def _predicate(driver: WebDriverOrWebElement):
return driver.find_element(*locator).is_selected()
return _predicate
def element_selection_state_to_be(element: WebElement, is_selected: bool) -> Callable[[Any], bool]:
"""An expectation for checking if the given element is selected.
element is WebElement object is_selected is a Boolean.
"""
def _predicate(_):
return element.is_selected() == is_selected
return _predicate
def element_located_selection_state_to_be(
locator: Tuple[str, str], is_selected: bool
) -> Callable[[WebDriverOrWebElement], bool]:
"""An expectation to locate an element and check if the selection state
specified is in that state.
locator is a tuple of (by, path) is_selected is a boolean
"""
def _predicate(driver: WebDriverOrWebElement):
try:
element = driver.find_element(*locator)
return element.is_selected() == is_selected
except StaleElementReferenceException:
return False
return _predicate
def number_of_windows_to_be(num_windows: int) -> Callable[[WebDriver], bool]:
"""An expectation for the number of windows to be a certain value."""
def _predicate(driver: WebDriver):
return len(driver.window_handles) == num_windows
return _predicate
def new_window_is_opened(current_handles: List[str]) -> Callable[[WebDriver], bool]:
"""An expectation that a new window will be opened and have the number of
windows handles increase."""
def _predicate(driver: WebDriver):
return len(driver.window_handles) > len(current_handles)
return _predicate
def alert_is_present() -> Callable[[WebDriver], Union[Alert, Literal[False]]]:
"""An expectation for checking if an alert is currently present and
switching to it."""
def _predicate(driver: WebDriver):
try:
return driver.switch_to.alert
except NoAlertPresentException:
return False
return _predicate
def element_attribute_to_include(locator: Tuple[str, str], attribute_: str) -> Callable[[WebDriverOrWebElement], bool]:
"""An expectation for checking if the given attribute is included in the
specified element.
locator, attribute
"""
def _predicate(driver: WebDriverOrWebElement):
try:
element_attribute = driver.find_element(*locator).get_attribute(attribute_)
return element_attribute is not None
except StaleElementReferenceException:
return False
return _predicate
def any_of(*expected_conditions: Callable[[D], T]) -> Callable[[D], Union[Literal[False], T]]:
"""An expectation that any of multiple expected conditions is true.
Equivalent to a logical 'OR'. Returns results of the first matching
condition, or False if none do.
"""
def any_of_condition(driver: D):
for expected_condition in expected_conditions:
try:
result = expected_condition(driver)
if result:
return result
except WebDriverException:
pass
return False
return any_of_condition
def all_of(
*expected_conditions: Callable[[D], Union[T, Literal[False]]]
) -> Callable[[D], Union[List[T], Literal[False]]]:
"""An expectation that all of multiple expected conditions is true.
Equivalent to a logical 'AND'.
Returns: When any ExpectedCondition is not met: False.
When all ExpectedConditions are met: A List with each ExpectedCondition's return value.
"""
def all_of_condition(driver: D):
results: List[T] = []
for expected_condition in expected_conditions:
try:
result = expected_condition(driver)
if not result:
return False
results.append(result)
except WebDriverException:
return False
return results
return all_of_condition
def none_of(*expected_conditions: Callable[[D], Any]) -> Callable[[D], bool]:
"""An expectation that none of 1 or multiple expected conditions is true.
Equivalent to a logical 'NOT-OR'. Returns a Boolean
"""
def none_of_condition(driver: D):
for expected_condition in expected_conditions:
try:
result = expected_condition(driver)
if result:
return False
except WebDriverException:
pass
return True
return none_of_condition