def test_is_stale(session):
session.url = inline("<button>foo</button>")
button = session.find.css("button", all=False)
session.url = inline("<button>bar</button>")
response = click_element(session, button)
assert_error(response, "stale element reference")
def test_null_response_value(session):
session.url = inline("<div>")
session.url = inline("<p>")
response = back(session)
value = assert_success(response)
assert value is None
def test_connected_element(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
session.url = inline("<input>")
response = element_clear(session, element)
assert_error(response, "stale element reference")
def pages(session):
pages = [
inline("<p id=1>"),
inline("<p id=2>"),
]
for page in pages:
session.url = page
return pages
def test_data_urls(session):
test_pages = [
inline("<p id=1>"),
inline("<p id=2>"),
]
for page in test_pages:
session.url = page
assert session.url == test_pages[1]
response = back(session)
assert_success(response)
assert session.url == test_pages[0]
def test_element_stale(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
session.refresh()
result = get_element_css_value(session, element.id, "display")
assert_error(result, "stale element reference")
def test_handle_prompt_missing_value(session, create_dialog):
# 13.3 step 2
session.url = inline("<input id=foo>")
create_dialog(session)("alert", text="dismiss #1", result_var="dismiss1")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/property/id"
.format(session_id=session.session_id,
element_id="foo"))
assert_error(result, "unexpected alert open")
assert_dialog_handled(session, "dismiss #1")
create_dialog(session)("confirm", text="dismiss #2", result_var="dismiss2")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/property/id"
.format(session_id=session.session_id,
element_id="foo"))
assert_error(result, "unexpected alert open")
assert_dialog_handled(session, "dismiss #2")
create_dialog(session)("prompt", text="dismiss #3", result_var="dismiss3")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/property/id"
.format(session_id=session.session_id,
element_id="foo"))
assert_error(result, "unexpected alert open")
assert_dialog_handled(session, "dismiss #3")
def test_handle_prompt_accept(new_session):
# 13.3 step 2
_, session = new_session({"capabilities": {"alwaysMatch": {"unhandledPromptBehavior": "accept"}}})
session.url = inline("<input id=foo>")
create_dialog(session)("alert", text="dismiss #1", result_var="dismiss1")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/property/id"
.format(session_id=session.session_id,
element_id="foo"))
assert_success(result, "foo")
assert_dialog_handled(session, "dismiss #1")
create_dialog(session)("confirm", text="dismiss #2", result_var="dismiss2")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/property/id"
.format(session_id=session.session_id,
element_id="foo"))
assert_success(result, "foo")
assert_dialog_handled(session, "dismiss #2")
create_dialog(session)("prompt", text="dismiss #3", result_var="dismiss3")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/property/id"
.format(session_id=session.session_id,
element_id="foo"))
assert_success(result, "foo")
assert_dialog_handled(session, "dismiss #3")
def test_handle_prompt_accept(new_session):
# 13.2 step 2
_, session = new_session({"capabilities": {"alwaysMatch": {"unhandledPromptBehavior": "accept"}}})
session.url = inline("<input id=foo>")
create_dialog(session)("alert", text="dismiss #1", result_var="dismiss1")
result = get_attribute(session, "foo", "id")
assert_success(result, "foo")
assert_dialog_handled(session, "dismiss #1")
create_dialog(session)("confirm", text="dismiss #2", result_var="dismiss2")
result = get_attribute(session, "foo", "id")
assert_success(result, "foo")
assert_dialog_handled(session, "dismiss #2")
create_dialog(session)("prompt", text="dismiss #3", result_var="dismiss3")
result = get_attribute(session, "foo", "id")
assert_success(result, "foo")
assert_dialog_handled(session, "dismiss #3")
def test_scroll_into_element_view(session):
# 14.2 Step 4
session.url = inline("<input type=text value=Federer><div style= \"height: 200vh; width: 5000vh\">")
# Scroll to the bottom right of the page
session.execute_script("window.scrollTo(document.body.scrollWidth, document.body.scrollHeight);")
element = session.find.css("input", all=False)
# Clear and scroll back to the top of the page
response = clear(session, element)
assert_success(response)
# Check if element cleared is scrolled into view
rect = session.execute_script("return document.getElementsByTagName(\"input\")[0].getBoundingClientRect()")
pageDict = {}
pageDict["innerHeight"] = session.execute_script("return window.innerHeight")
pageDict["innerWidth"] = session.execute_script("return window.innerWidth")
pageDict["pageXOffset"] = session.execute_script("return window.pageXOffset")
pageDict["pageYOffset"] = session.execute_script("return window.pageYOffset")
assert rect["top"] < (pageDict["innerHeight"] + pageDict["pageYOffset"]) and \
rect["left"] < (pageDict["innerWidth"] + pageDict["pageXOffset"]) and \
(rect["top"] + element.rect["height"]) > pageDict["pageYOffset"] and \
(rect["left"] + element.rect["width"]) > pageDict["pageXOffset"]
def test_disabled_element_not_resettable(session):
# 14.2 Step 3
session.url = inline("<input type=text value=Federer disabled>")
element = session.find.css("input", all=False)
response = clear(session, element)
assert_error(response, "invalid element state")
def test_element_not_editable(session):
# 14.2 Step 3
session.url = inline("<p>This is not an editable paragraph.")
element = session.find.css("p", all=False)
response = clear(session, element)
assert_error(response, "invalid element state")
def test_clear_content_editable_resettable_element(session, element):
# 14.2 Step 8
url = element[1] + """<input id=focusCheck type=checkbox>
<input id=blurCheck type=checkbox>
<script>
var id = %s
document.getElementById("id").addEventListener("focus", checkFocus);
document.getElementById("id").addEventListener("blur", checkBlur);
document.getElementById("empty").addEventListener("focus", checkFocus);
document.getElementById("empty").addEventListener("blur", checkBlur);
function checkFocus() {
document.getElementById("focusCheck").checked = true;
}
function checkBlur() {
document.getElementById("blurCheck").checked = true;
}
</script>""" % element[0]
session.url = inline(url)
# Step 1
empty_element = session.find.css("#empty", all=False)
test_clear_element_helper(session, empty_element, False)
session.execute_script("document.getElementById(\"focusCheck\").checked = false;")
session.execute_script("document.getElementById(\"blurCheck\").checked = false;")
# Step 2 - 4
test_element = session.find.css("#" + element[0], all=False)
test_clear_element_helper(session, test_element, True)
def test_element_pointer_events_disabled(session):
# 14.2 Step 7
session.url = inline("<input type=text value=Federer style=\"pointer-events: none\">")
element = session.find.css("input", all=False)
response = clear(session, element)
assert_error(response, "invalid element state")
def test_element_readonly(session):
# 14.2 Step 7
session.url = inline("<input type=text readonly value=Federer>")
element = session.find.css("input", all=False)
response = clear(session, element)
assert_error(response, "invalid element state")
def origin_doc(inner_style, outer_style=""):
return inline("""
<div id="outer" style="{1}"
onmousemove="window.coords = {{x: event.clientX, y: event.clientY}}">
<div id="inner" style="{0}"></div>
</div>
""".format(inner_style, outer_style))
def test_not_blurred(session, tag):
session.url = inline("<%s>" % tag)
element = session.find.css(tag, all=False)
response = element_send_keys(session, element, "")
assert_success(response)
assert_element_has_focus(element)
def test_stale(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
session.refresh()
result = take_element_screenshot(session, element.id)
assert_error(result, "stale element reference")
def test_click_event_bubbles_to_parents(session):
session.url = inline("""
<style>
body * {
margin: 10px;
padding: 10px;
border: 1px solid blue;
}
</style>
<div id=three>THREE
<div id=two>TWO
<div id=one>ONE</div>
</div>
</div>
<script>
window.clicks = [];
for (let level of document.querySelectorAll("div")) {
level.addEventListener("click", ({currentTarget}) => {
window.clicks.push(currentTarget);
});
}
</script>
""")
three, two, one = session.find.css("div")
one.click()
clicks = session.execute_script("return window.clicks")
assert one in clicks
assert two in clicks
assert three in clicks
def test_xhtml_namespace(session, using, value):
session.url = inline("""<a href="#" id="linkText">full link text</a>""", doctype="xhtml")
expected = session.execute_script("return document.links[0]")
response = find_element(session, using, value)
value = assert_success(response)
assert_same_element(session, value, expected)
def test_readonly_element(session):
session.url = inline("<input readonly>")
element = session.find.css("input", all=False)
response = element_send_keys(session, element, "foo")
assert_success(response)
assert element.property("value") == ""
def test_handle_prompt_accept(new_session, add_browser_capabilites):
# 13.6 step 2
_, session = new_session({"capabilities": {"alwaysMatch": add_browser_capabilites({"unhandledPromptBehavior": "accept"})}})
session.url = inline("<input id=foo>")
element = session.find.css("#foo", all=False)
create_dialog(session)("alert", text="dismiss #1", result_var="dismiss1")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/name"
.format(session_id=session.session_id,
element_id=element.id))
assert_success(result, "input")
assert_dialog_handled(session, "dismiss #1")
create_dialog(session)("confirm", text="dismiss #2", result_var="dismiss2")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/name"
.format(session_id=session.session_id,
element_id=element.id))
assert_success(result, "input")
assert_dialog_handled(session, "dismiss #2")
create_dialog(session)("prompt", text="dismiss #3", result_var="dismiss3")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/name"
.format(session_id=session.session_id,
element_id=element.id))
assert_success(result, "input")
assert_dialog_handled(session, "dismiss #3")
def test_close_browsing_context_with_dismissed_beforeunload_prompt(session, create_window):
original_handles = session.handles
new_handle = create_window()
session.window_handle = new_handle
session.url = inline("""
<input type="text">
<script>
window.addEventListener("beforeunload", function (event) {
event.preventDefault();
});
</script>
""")
session.find.css("input", all=False).send_keys("foo")
response = close(session)
handles = assert_success(response, original_handles)
assert session.handles == original_handles
assert new_handle not in handles
# A beforeunload prompt has to be automatically dismissed
with pytest.raises(error.NoSuchWindowException):
session.alert.text
def test_handle_prompt_missing_value(session):
# 13.6 step 2
session.url = inline("<input id=foo>")
element = session.find.css("#foo", all=False)
create_dialog(session)("alert", text="dismiss #1", result_var="dismiss1")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/name"
.format(session_id=session.session_id,
element_id=element.id))
assert_error(result, "unexpected alert open")
assert_dialog_handled(session, "dismiss #1")
create_dialog(session)("confirm", text="dismiss #2", result_var="dismiss2")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/name"
.format(session_id=session.session_id,
element_id=element.id))
assert_error(result, "unexpected alert open")
assert_dialog_handled(session, "dismiss #2")
create_dialog(session)("prompt", text="dismiss #3", result_var="dismiss3")
result = session.transport.send("GET", "session/{session_id}/element/{element_id}/name"
.format(session_id=session.session_id,
element_id=element.id))
assert_error(result, "unexpected alert open")
assert_dialog_handled(session, "dismiss #3")
def test_duplicated_cookie(session, url):
session.url = url("/common/blank.html")
clear_all_cookies(session)
create_cookie_request = {
"cookie": {
"name": "hello",
"value": "world",
"domain": "web-platform.test",
"path": "/",
"httpOnly": False,
"secure": False
}
}
result = session.transport.send("POST", "session/%s/cookie" % session.session_id, create_cookie_request)
assert result.status == 200
assert "value" in result.body
assert isinstance(result.body["value"], dict)
session.url = inline("<script>document.cookie = 'hello=newworld; domain=web-platform.test; path=/';</script>")
result = session.transport.send("GET", "session/%s/cookie" % session.session_id)
assert result.status == 200
assert "value" in result.body
assert isinstance(result.body["value"], list)
assert len(result.body["value"]) == 1
assert isinstance(result.body["value"][0], dict)
cookie = result.body["value"][0]
assert "name" in cookie
assert isinstance(cookie["name"], basestring)
assert "value" in cookie
assert isinstance(cookie["value"], basestring)
assert cookie["name"] == "hello"
assert cookie["value"] == "newworld"
def test_null_response_value(session):
session.url = inline(iframe("<p>foo"))
frame_element = session.find.css("iframe", all=False)
response = switch_to_frame(session, frame_element)
value = assert_success(response)
assert value is None
def test_null_response_value(session):
session.url = inline("<p>foo")
element = session.find.css("p", all=False)
response = element_click(session, element)
value = assert_success(response)
assert value is None
def test_null_response_value(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
response = element_send_keys(session, element, "foo")
value = assert_success(response)
assert value is None
def test_resettable_element_does_not_satisfy_validation_constraints(session, type, invalid_value):
"""
Some UAs allow invalid input to certain types of constrained
form controls. For example, Gecko allows non-valid characters
to be typed into <input type=number> but Chrome does not.
Since we want to test that Element Clear works for clearing the
invalid characters in these UAs, it is fine to skip this test
where UAs do not allow the element to not satisfy its constraints.
"""
session.url = inline("<input type=%s>" % type)
element = session.find.css("input", all=False)
def is_valid(element):
return session.execute_script("""
var input = arguments[0];
return input.validity.valid;
""", args=(element,))
# value property does not get updated if the input is invalid
element.send_keys(invalid_value)
# UA does not allow invalid input for this form control type
if is_valid(element):
return
response = element_clear(session, element)
assert_success(response)
assert is_valid(element)
def test_transparent_element(session):
session.url = inline("""<input style="opacity: 0">""")
element = session.find.css("input", all=False)
response = element_send_keys(session, element, "foo")
assert_success(response)
assert element.property("value") == "foo"
def test_disabled(session):
session.url = inline("""<input disabled>""")
element = session.find.css("input", all=False)
response = element_send_keys(session, element, "foo")
assert_error(response, "element not interactable")
def test_not_a_focusable_element(session):
session.url = inline("<div>foo</div>")
element = session.find.css("div", all=False)
response = element_send_keys(session, element, "foo")
assert_error(response, "element not interactable")
def test_no_iframe(session):
session.url = inline("<title>Foobar</title><h2>Hello</h2>")
result = get_title(session)
assert_success(result, "Foobar")
def test_non_editable_inputs(session, type):
session.url = inline("<input type=%s>" % type)
element = session.find.css("input", all=False)
response = element_clear(session, element)
assert_error(response, "invalid element state")
def test_textarea_readonly(session):
session.url = inline("<textarea readonly></textarea>")
element = session.find.css("textarea", all=False)
response = element_clear(session, element)
assert_error(response, "invalid element state")
def test_null_response_value(session, url):
session.url = inline("<script>window.alert('Hello');</script>")
response = dismiss_alert(session)
value = assert_success(response)
assert value is None
def test_property_name_value(session):
session.url = inline("""<input style="display: block">""")
element = session.find.css("input", all=False)
result = get_element_css_value(session, element.id, "display")
assert_success(result, "block")
def test_disabled_element(session):
session.url = inline("<input disabled=\"false\">")
element = session.find.css("input", all=False)
response = send_keys_to_element(session, element, "foo")
assert_error(response, "element not interactable")
def test_hidden_element(session):
session.url = inline("<input style=\"visibility: hidden\">")
element = session.find.css("input", all=False)
response = send_keys_to_element(session, element, "foo")
assert_error(response, "element not interactable")
def test_dismiss_alert(session):
session.url = inline("<script>window.alert('Hello');</script>")
response = dismiss_alert(session)
assert_success(response)
def test_dismiss_confirm(session):
session.url = inline(
"<script>window.result = window.confirm('Hello');</script>")
response = dismiss_alert(session)
assert_success(response)
assert session.execute_script("return window.result;") is False
def test_not_displayed_element(session):
session.url = inline("""<input style="display: none">""")
element = session.find.css("input", all=False)
response = element_send_keys(session, element, "foo")
assert_error(response, "element not interactable")
def test_input_readonly(session, type):
session.url = inline("<input type=%s readonly>" % type)
element = session.find.css("input", all=False)
response = element_clear(session, element)
assert_error(response, "invalid element state")
# META: timeout=long
from tests.support.asserts import assert_error, assert_success, assert_dialog_handled
from tests.support.fixtures import create_dialog
from tests.support.inline import inline
alert_doc = inline("<script>window.alert()</script>")
def read_global(session, name):
return session.execute_script("return %s;" % name)
def fullscreen(session):
return session.transport.send(
"POST", "session/%s/window/fullscreen" % session.session_id)
# 10.7.5 Fullscreen Window
def test_no_browsing_context(session, create_window):
"""
1. If the current top-level browsing context is no longer open,
return error with error code no such window.
"""
session.window_handle = create_window()
session.close()
response = fullscreen(session)
assert_error(response, "no such window")
def test_button(session):
session.url = inline("<button></button>")
button = session.find.css("button", all=False)
response = element_clear(session, button)
assert_error(response, "invalid element state")
def test_parent_htmldocument(session):
session.url = inline("")
from_element = session.execute_script("return document.documentElement")
response = find_element(session, from_element.id, "xpath", "..")
assert_success(response)
def test_pointer_interactable(session):
session.url = inline("<input style='margin-left: -1000px' value=foobar>")
element = session.find.css("input", all=False)
response = element_clear(session, element)
assert_error(response, "element not interactable")
import pytest
from tests.support.asserts import assert_success
from tests.support.inline import iframe, inline
"""
Tests that WebDriver can transcend site origins.
Many modern browsers impose strict cross-origin checks,
and WebDriver should be able to transcend these.
Although an implementation detail, certain browsers
also enforce process isolation based on site origin.
This is known to sometimes cause problems for WebDriver implementations.
"""
frame_doc = inline("<title>cheese</title><p>frame")
one_frame_doc = inline("<title>bar</title><iframe src='%s'></iframe>" %
frame_doc)
nested_frames_doc = inline("<title>foo</title><iframe src='%s'></iframe>" %
one_frame_doc)
def get_title(session):
return session.transport.send(
"GET", "session/{session_id}/title".format(**vars(session)))
def test_no_iframe(session):
session.url = inline("<title>Foobar</title><h2>Hello</h2>")
result = get_title(session)
def test_no_element(session, using, value):
# Step 8 - 9
session.url = inline("<div></div>")
element = session.find.css("div", all=False)
response = find_elements(session, element.id, using, value)
assert response.body["value"] == []
def test_no_element(session, using, value):
# Step 8 - 9
session.url = inline("<div></div>")
element = session.find.css("div", all=False)
response = find_element(session, element.id, using, value)
assert_error(response, "no such element")
def test_find_elements(session, using, value):
# Step 8 - 9
session.url = inline("<div><a href=# id=linkText>full link text</a></div>")
element = session.find.css("div", all=False)
response = find_elements(session, element.id, using, value)
assert_success(response)
def test_accept_alert(session):
# 18.2 step 3
session.url = inline("<script>window.alert('Hello');</script>")
response = accept_alert(session)
assert_success(response)
def test_accept_prompt(session):
# 18.2 step 3
session.url = inline("<script>window.result = window.prompt('Enter Your Name: ', 'Federer');</script>")
response = accept_alert(session)
assert_success(response)
assert session.execute_script("return window.result") == "Federer"
def test_accept_confirm(session):
session.url = inline(
"<script>window.result = window.confirm('Hello');</script>")
response = accept_alert(session)
assert_success(response)
assert session.execute_script("return window.result") is True
def test_visibility_hidden(session):
session.url = inline("""<input style="visibility: hidden">""")
element = session.find.css("input", all=False)
response = element_send_keys(session, element, "foo")
assert_error(response, "element not interactable")
from six import text_type
from tests.support import platform_name
from tests.support.inline import inline
from tests.support.asserts import assert_error, assert_success
doc = inline("<p>frame")
alert_doc = inline("<script>window.alert()</script>")
def get_current_url(session):
return session.transport.send(
"GET", "session/{session_id}/url".format(**vars(session)))
def test_no_browsing_context(session, closed_window):
response = get_current_url(session)
assert_error(response, "no such window")
def test_get_current_url_matches_location(session):
session.url = doc
response = get_current_url(session)
assert_success(response, doc)
def test_get_current_url_payload(session):
session.start()
response = get_current_url(session)
def test_find_element(session, using, value):
# Step 8 - 9
session.url = inline("<a href=# id=linkText>full link text</a>")
response = find_element(session, using, value)
assert_success(response)
def test_property_name_not_existent(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
result = get_element_css_value(session, element.id, "foo")
assert_success(result, "")
def test_htmldocument(session, using, value):
session.url = inline("")
response = find_element(session, using, value)
assert_success(response)
def test_find_element_partial_link_text(session, document, value):
# Step 8 - 9
session.url = inline(document)
response = find_element(session, "partial link text", value)
assert_success(response)
