Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-22 13:55:34 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision 10168e9a5d44efbc6e7d416d1d454eb9c9f1396c

Browse source
This commit is contained in:
Josh Matthews 2018-01-31 09:13:41 -05:00
parent c88dc51d03
commit 0e1caebaf4
791 changed files with 23381 additions and 5501 deletions
Download patch file Download diff file Expand all files Collapse all files

1
tests/wpt/web-platform-tests/webdriver/OWNERS
View file

@ -1,5 +1,4 @@
@AutomatedTester
@JKereliuk
@andreastt
@lukeis
@mjzffr

4
tests/wpt/web-platform-tests/webdriver/tests/__init__.py
View file

@ -0,0 +1,4 @@
import pytest
# Enable pytest assert introspection for assertion helper
pytest.register_assert_rewrite('tests.support.asserts')

3
tests/wpt/web-platform-tests/webdriver/tests/actions/mouse.py
View file

@ -1,7 +1,8 @@
import pytest
from tests.actions.support.mouse import assert_move_to_coordinates, get_center
from tests.actions.support.mouse import get_center
from tests.actions.support.refine import get_events, filter_dict
from tests.support.asserts import assert_move_to_coordinates
from tests.support.inline import inline
from tests.support.wait import wait

3
tests/wpt/web-platform-tests/webdriver/tests/actions/mouse_dblclick.py
View file

@ -1,7 +1,8 @@
import pytest
from tests.actions.support.mouse import assert_move_to_coordinates, get_center
from tests.actions.support.mouse import get_center
from tests.actions.support.refine import get_events, filter_dict
from tests.support.asserts import assert_move_to_coordinates
_DBLCLICK_INTERVAL = 640

8
tests/wpt/web-platform-tests/webdriver/tests/actions/support/mouse.py
View file

@ -1,11 +1,3 @@
def assert_move_to_coordinates(point, target, events):
for e in events:
if e["type"] != "mousemove":
assert e["pageX"] == point["x"]
assert e["pageY"] == point["y"]
assert e["target"] == target
def get_center(rect):
return {
"x": rect["width"] / 2 + rect["x"],

14
tests/wpt/web-platform-tests/webdriver/tests/cookies/add_cookie.py
View file

@ -17,7 +17,7 @@ def test_add_domain_cookie(session, url, server_config):
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)
assert result.body["value"] is None
result = session.transport.send("GET", "session/%s/cookie" % session.session_id)
assert result.status == 200
@ -54,7 +54,7 @@ def test_add_cookie_for_ip(session, url, server_config, configuration):
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)
assert result.body["value"] is None
result = session.transport.send("GET", "session/%s/cookie" % session.session_id)
assert result.status == 200
@ -89,7 +89,7 @@ def test_add_non_session_cookie(session, url):
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)
assert result.body["value"] is None
result = session.transport.send("GET", "session/%s/cookie" % session.session_id)
assert result.status == 200
@ -122,7 +122,7 @@ def test_add_session_cookie(session, url):
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)
assert result.body["value"] is None
result = session.transport.send("GET", "session/%s/cookie" % session.session_id)
assert result.status == 200
@ -136,8 +136,8 @@ def test_add_session_cookie(session, url):
assert isinstance(cookie["name"], basestring)
assert "value" in cookie
assert isinstance(cookie["value"], basestring)
assert "expiry" in cookie
assert cookie.get("expiry") is None
if "expiry" in cookie:
assert cookie.get("expiry") is None
assert cookie["name"] == "hello"
assert cookie["value"] == "world"
@ -155,7 +155,7 @@ def test_add_session_cookie_with_leading_dot_character_in_domain(session, url, s
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)
assert result.body["value"] is None
result = session.transport.send("GET", "session/%s/cookie" % session.session_id)
assert result.status == 200

3
tests/wpt/web-platform-tests/webdriver/tests/cookies/delete_cookie.py
View file

@ -119,5 +119,4 @@ def test_unknown_cookie(session):
response = delete_cookie(session, "stilton")
assert response.status == 200
assert "value" in response.body
assert isinstance(response.body["value"], dict)
assert response.body["value"] == {}
assert response.body["value"] is None

6
tests/wpt/web-platform-tests/webdriver/tests/cookies/get_named_cookie.py
View file

@ -26,8 +26,8 @@ def test_get_named_session_cookie(session, url):
assert isinstance(cookie["secure"], bool)
assert "httpOnly" in cookie
assert isinstance(cookie["httpOnly"], bool)
assert "expiry" in cookie
assert cookie.get("expiry") is None
if "expiry" in cookie:
assert cookie.get("expiry") is None
assert cookie["name"] == "foo"
assert cookie["value"] == "bar"
@ -77,7 +77,7 @@ def test_duplicated_cookie(session, url, server_config):
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)
assert result.body["value"] is None
session.url = inline("<script>document.cookie = 'hello=newworld; domain=%s; path=/';</script>" % server_config["domains"][""])
result = session.transport.send("GET", "session/%s/cookie" % session.session_id)

12
tests/wpt/web-platform-tests/webdriver/tests/element_click/select.py
View file

@ -211,3 +211,15 @@ def test_out_of_view_multiple(session):
last_option = options[-1]
last_option.click()
assert last_option.selected
def test_option_disabled(session):
session.url = inline("""
<select>
<option disabled>foo
</select>""")
option = session.find.css("option", all=False)
assert not option.selected
option.click()
assert not option.selected

94
tests/wpt/web-platform-tests/webdriver/tests/element_send_keys/form_controls.py Normal file
View file

@ -0,0 +1,94 @@
import pytest
from tests.support.asserts import assert_error, assert_same_element, assert_success
from tests.support.inline import inline
def element_send_keys(session, element, text):
return session.transport.send(
"POST",
"/session/{session_id}/element/{element_id}/value".format(
session_id=session.session_id,
element_id=element.id),
{"text": text})
def add_event_listeners(element):
element.session.execute_script("""
let [target] = arguments;
window.events = [];
for (let expected of ["focus", "blur", "change", "keypress", "keydown", "keyup", "input"]) {
target.addEventListener(expected, ({type}) => window.events.push(type));
}
""", args=(element,))
def get_events(session):
return session.execute_script("return window.events")
def test_input(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
assert element.property("value") == ""
element_send_keys(session, element, "foo")
assert element.property("value") == "foo"
def test_textarea(session):
session.url = inline("<textarea>")
element = session.find.css("textarea", all=False)
assert element.property("value") == ""
element_send_keys(session, element, "foo")
assert element.property("value") == "foo"
def test_input_append(session):
session.url = inline("<input value=a>")
element = session.find.css("input", all=False)
assert element.property("value") == "a"
element_send_keys(session, element, "b")
assert element.property("value") == "ab"
element_send_keys(session, element, "c")
assert element.property("value") == "abc"
def test_textarea_append(session):
session.url = inline("<textarea>a</textarea>")
element = session.find.css("textarea", all=False)
assert element.property("value") == "a"
element_send_keys(session, element, "b")
assert element.property("value") == "ab"
element_send_keys(session, element, "c")
assert element.property("value") == "abc"
@pytest.mark.parametrize("tag", ["input", "textarea"])
def test_events(session, tag):
session.url = inline("<%s>" % tag)
element = session.find.css(tag, all=False)
add_event_listeners(element)
element_send_keys(session, element, "foo")
assert element.property("value") == "foo"
assert get_events(session) == ["focus",
"keydown",
"keypress",
"input",
"keyup",
"keydown",
"keypress",
"input",
"keyup",
"keydown",
"keypress",
"input",
"keyup",
"change",
"blur"]

4
tests/wpt/web-platform-tests/webdriver/tests/element_send_keys/interactability.py
View file

@ -46,7 +46,7 @@ def test_document_element_is_interactable(session):
response = send_keys_to_element(session, element, "foo")
assert_success(response)
assert_same_element(session, element, session.active_element)
assert_same_element(session, body, session.active_element)
assert result.property("value") == "foo"
@ -65,7 +65,7 @@ def test_iframe_is_interactable(session):
response = send_keys_to_element(session, frame, "foo")
assert_success(response)
assert_same_element(session, frame, session.active_element)
assert_same_element(session, body, session.active_element)
# Any key events are immediately routed to the nested
# browsing context's active document.

0
tests/wpt/web-platform-tests/webdriver/tests/execute_async_script/__init__.py Normal file
View file

0
tests/wpt/web-platform-tests/webdriver/tests/execute_script/__init__.py Normal file
View file

525
tests/wpt/web-platform-tests/webdriver/tests/interaction/element_clear.py
View file

@ -1,185 +1,390 @@
# META: timeout=long
import pytest
from tests.support.asserts import assert_error, assert_success
from tests.support.asserts import (
assert_element_has_focus,
assert_error,
assert_success,
)
from tests.support.inline import inline
def clear(session, element):
return session.transport.send("POST", "session/{session_id}/element/{element_id}/clear"
.format(session_id=session.session_id,
element_id=element.id))
def add_event_listeners(element):
element.session.execute_script("""
let [target] = arguments;
window.events = [];
for (let expected of ["focus", "blur", "change"]) {
target.addEventListener(expected, ({type}) => window.events.push(type));
}
""", args=(element,))
# 14.2 Element Clear
def get_events(session):
return session.execute_script("return window.events")
def test_no_browsing_context(session, create_window):
# 14.2 step 1
session.url = inline("<p>This is not an editable paragraph.")
element = session.find.css("p", all=False)
session.window_handle = create_window()
@pytest.fixture(scope="session")
def text_file(tmpdir_factory):
fh = tmpdir_factory.mktemp("tmp").join("hello.txt")
fh.write("hello")
return fh
def element_clear(session, element):
return session.transport.send("POST", "/session/%s/element/%s/clear" %
(session.session_id, element.id))
def test_closed_context(session, create_window):
new_window = create_window()
session.window_handle = new_window
session.url = inline("<input>")
element = session.find.css("input", all=False)
session.close()
response = clear(session, element)
response = element_clear(session, element)
assert_error(response, "no such window")
def test_element_not_found(session):
# 14.2 Step 2
response = session.transport.send("POST", "session/{session_id}/element/{element_id}/clear"
.format(session_id=session.session_id,
element_id="box1"))
def test_connected_element(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
assert_error(response, "no such element")
session.url = inline("<input>")
response = element_clear(session, element)
assert_error(response, "stale element reference")
def test_element_not_editable(session):
# 14.2 Step 3
session.url = inline("<p>This is not an editable paragraph.")
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")
def test_keyboard_interactable(session):
session.url = inline("""
<input value=foobar>
<div></div>
<style>
div {
position: absolute;
background: blue;
top: 0;
}
</style>
""")
element = session.find.css("input", all=False)
assert element.property("value") == "foobar"
response = element_clear(session, element)
assert_success(response)
assert element.property("value") == ""
@pytest.mark.parametrize("type,value,default",
[("number", "42", ""),
("range", "42", "50"),
("email", "foo@example.com", ""),
("password", "password", ""),
("search", "search", ""),
("tel", "999", ""),
("text", "text", ""),
("url", "https://example.com/", ""),
("color", "#ff0000", "#000000"),
("date", "2017-12-26", ""),
("datetime", "2017-12-26T19:48", ""),
("datetime-local", "2017-12-26T19:48", ""),
("time", "19:48", ""),
("month", "2017-11", ""),
("week", "2017-W52", "")])
def test_input(session, type, value, default):
session.url = inline("<input type=%s value='%s'>" % (type, value))
element = session.find.css("input", all=False)
add_event_listeners(element)
assert element.property("value") == value
response = element_clear(session, element)
assert_success(response)
assert element.property("value") == default
events = get_events(session)
assert "focus" in events
assert "change" in events
assert "blur" in events
assert_element_has_focus(session.execute_script("return document.body"))
@pytest.mark.parametrize("type",
["number",
"range",
"email",
"password",
"search",
"tel",
"text",
"url",
"color",
"date",
"datetime",
"datetime-local",
"time",
"month",
"week",
"file"])
def test_input_disabled(session, type):
session.url = inline("<input type=%s disabled>" % type)
element = session.find.css("input", all=False)
response = element_clear(session, element)
assert_error(response, "invalid element state")
@pytest.mark.parametrize("type",
["number",
"range",
"email",
"password",
"search",
"tel",
"text",
"url",
"color",
"date",
"datetime",
"datetime-local",
"time",
"month",
"week",
"file"])
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")
def test_textarea(session):
session.url = inline("<textarea>foobar</textarea>")
element = session.find.css("textarea", all=False)
add_event_listeners(element)
assert element.property("value") == "foobar"
response = element_clear(session, element)
assert_success(response)
assert element.property("value") == ""
events = get_events(session)
assert "focus" in events
assert "change" in events
assert "blur" in events
def test_textarea_disabled(session):
session.url = inline("<textarea disabled></textarea>")
element = session.find.css("textarea", 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_input_file(session, text_file):
session.url = inline("<input type=file>")
element = session.find.css("input", all=False)
element.send_keys(str(text_file))
response = element_clear(session, element)
assert_success(response)
assert element.property("value") == ""
def test_input_file_multiple(session, text_file):
session.url = inline("<input type=file multiple>")
element = session.find.css("input", all=False)
element.send_keys(str(text_file))
element.send_keys(str(text_file))
response = element_clear(session, element)
assert_success(response)
assert element.property("value") == ""
def test_select(session):
session.url = inline("""
<select>
<option>foo
</select>
""")
select = session.find.css("select", all=False)
option = session.find.css("option", all=False)
response = element_clear(session, select)
assert_error(response, "invalid element state")
response = element_clear(session, option)
assert_error(response, "invalid element state")
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_button_with_subtree(session):
"""
Whilst an <input> is normally editable, the focusable area
where it is placed will default to the <button>. I.e. if you
try to click <input> to focus it, you will hit the <button>.
"""
session.url = inline("""
<button>
<input value=foobar>
</button>
""")
text_field = session.find.css("input", all=False)
response = element_clear(session, text_field)
assert_error(response, "element not interactable")
def test_contenteditable(session):
session.url = inline("<p contenteditable>foobar</p>")
element = session.find.css("p", all=False)
response = clear(session, element)
assert_error(response, "invalid element state")
add_event_listeners(element)
assert element.property("innerHTML") == "foobar"
def test_button_element_not_resettable(session):
# 14.2 Step 3
session.url = inline("<input type=button value=Federer>")
element = session.find.css("input", all=False)
response = clear(session, element)
assert_error(response, "invalid element state")
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_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)
response = element_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"]
assert element.property("innerHTML") == ""
assert get_events(session) == ["focus", "change", "blur"]
assert_element_has_focus(session.execute_script("return document.body"))
# TODO
# Any suggestions on implementation?
# def test_session_implicit_wait_timeout(session):
# 14.2 Step 5
# TODO
# Any suggestions on implementation?
# def test_element_not_interactable(session):
# # 14.2 Step 6
# assert_error(response, "element not interactable")
def test_designmode(session):
session.url = inline("foobar")
element = session.find.css("body", all=False)
assert element.property("innerHTML") == "foobar"
session.execute_script("document.designMode = 'on'")
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 test_element_disabled(session):
# 14.2 Step 7
session.url = inline("<input type=text disabled value=Federer>")
element = session.find.css("input", all=False)
response = clear(session, element)
assert_error(response, "invalid element state")
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")
@pytest.mark.parametrize("element", [["text", "<input id=text type=text value=\"Federer\"><input id=empty type=text value=\"\">"],
["search", "<input id=search type=search value=\"Federer\"><input id=empty type=search value=\"\">"],
["url", "<input id=url type=url value=\"www.hello.com\"><input id=empty type=url value=\"\">"],
["tele", "<input id=tele type=telephone value=\"2061234567\"><input id=empty type=telephone value=\"\">"],
["email", "<input id=email type=email value=\"hello@world.com\"><input id=empty type=email value=\"\">"],
["password", "<input id=password type=password value=\"pass123\"><input id=empty type=password value=\"\">"],
["date", "<input id=date type=date value=\"2017-12-25\"><input id=empty type=date value=\"\">"],
["time", "<input id=time type=time value=\"11:11\"><input id=empty type=time value=\"\">"],
["number", "<input id=number type=number value=\"19\"><input id=empty type=number value=\"\">"],
["range", "<input id=range type=range min=\"0\" max=\"10\"><input id=empty type=range value=\"\">"],
["color", "<input id=color type=color value=\"#ff0000\"><input id=empty type=color value=\"\">"],
["file", "<input id=file type=file value=\"C:\\helloworld.txt\"><input id=empty type=file value=\"\">"],
["textarea", "<textarea id=textarea>Hello World</textarea><textarea id=empty></textarea>"],
["sel", "<select id=sel><option></option><option>a</option><option>b</option></select><select id=empty><option></option></select>"],
["out", "<output id=out value=100></output><output id=empty></output>"],
["para", "<p id=para contenteditable=true>This is an editable paragraph.</p><p id=empty contenteditable=true></p>"]])
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)
clear_element_test_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)
clear_element_test_helper(session, test_element, True)
def clear_element_test_helper(session, element, value):
response = clear(session, element)
response = element_clear(session, element)
assert_success(response)
response = session.execute_script("return document.getElementById(\"focusCheck\").checked;")
assert response is value
response = session.execute_script("return document.getElementById(\"blurCheck\").checked;")
assert response is value
if element.name == "p":
response = session.execute_script("return document.getElementById(\"para\").innerHTML;")
assert response == ""
else:
assert element.property("value") == ""
assert element.property("innerHTML") == "<br>"
assert_element_has_focus(session.execute_script("return document.body"))
def test_resettable_element_focus_when_empty(session):
session.url = inline("<input>")
element = session.find.css("input", all=False)
add_event_listeners(element)
assert element.property("value") == ""
response = element_clear(session, element)
assert_success(response)
assert element.property("value") == ""
assert get_events(session) == []
@pytest.mark.parametrize("type,invalid_value",
[("number", "foo"),
("range", "foo"),
("email", "foo"),
("url", "foo"),
("color", "foo"),
("date", "foo"),
("datetime", "foo"),
("datetime-local", "foo"),
("time", "foo"),
("month", "foo"),
("week", "foo")])
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("""
let [input] = arguments;
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)
@pytest.mark.parametrize("type",
["checkbox",
"radio",
"hidden",
"submit",
"button",
"image"])
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_scroll_into_view(session):
session.url = inline("""
<input value=foobar>
<div style='height: 200vh; width: 5000vh'>
""")
element = session.find.css("input", all=False)
assert element.property("value") == "foobar"
assert session.execute_script("return window.scrollY") == 0
# scroll to the bottom right of the page
session.execute_script("""
let {scrollWidth, scrollHeight} = document.body;
window.scrollTo(scrollWidth, scrollHeight);
""")
# clear and scroll back to the top of the page
response = element_clear(session, element)
assert_success(response)
assert element.property("value") == ""
# check if element cleared is scrolled into view
rect = session.execute_script("""
let [input] = arguments;
return input.getBoundingClientRect();
""", args=(element,))
window = session.execute_script("""
let {innerHeight, innerWidth, pageXOffset, pageYOffset} = window;
return {innerHeight, innerWidth, pageXOffset, pageYOffset};
""")
assert rect["top"] < (window["innerHeight"] + window["pageYOffset"]) and \
rect["left"] < (window["innerWidth"] + window["pageXOffset"]) and \
(rect["top"] + element.rect["height"]) > window["pageYOffset"] and \
(rect["left"] + element.rect["width"]) > window["pageXOffset"]

2
tests/wpt/web-platform-tests/webdriver/tests/sessions/new_session/response.py
View file

@ -50,5 +50,5 @@ def test_timeouts(new_session, add_browser_capabilites, platform_name):
}
def test_pageLoadStrategy(new_session, add_browser_capabilites, platform_name):
resp, _ = new_session({"capabilities": add_browser_capabilites({"alwaysMatch": {"pageLoadStrategy": "eager"}})})
resp, _ = new_session({"capabilities": {"alwaysMatch": add_browser_capabilites({"pageLoadStrategy": "eager"})}})
assert resp["capabilities"]["pageLoadStrategy"] == "eager"

2
tests/wpt/web-platform-tests/webdriver/tests/sessions/new_session/support/create.py
View file

@ -6,7 +6,7 @@ valid_data = [
("platformName", [None]),
("pageLoadStrategy", ["none", "eager", "normal", None]),
("proxy", [None]),
("timeouts", [{"script": 0, "pageLoad": 2.0, "implicit": 2**64 - 1},
("timeouts", [{"script": 0, "pageLoad": 2.0, "implicit": 2**53 - 1},
{"script": 50, "pageLoad": 25},
{"script": 500},
{}]),

2
tests/wpt/web-platform-tests/webdriver/tests/state/get_element_attribute.py
View file

@ -1,3 +1,5 @@
# META: timeout=long
import pytest
from tests.support.asserts import assert_error, assert_success, assert_dialog_handled

2
tests/wpt/web-platform-tests/webdriver/tests/state/get_element_property.py
View file

@ -1,3 +1,5 @@
# META: timeout=long
from tests.support.asserts import assert_error, assert_dialog_handled, assert_success
from tests.support.inline import inline
from tests.support.fixtures import create_dialog

2
tests/wpt/web-platform-tests/webdriver/tests/state/get_element_tag_name.py
View file

@ -1,3 +1,5 @@
# META: timeout=long
from tests.support.asserts import assert_error, assert_dialog_handled, assert_success
from tests.support.inline import inline
from tests.support.fixtures import create_dialog

2
tests/wpt/web-platform-tests/webdriver/tests/state/is_element_selected.py
View file

@ -1,3 +1,5 @@
# META: timeout=long
from tests.support.asserts import assert_error, assert_dialog_handled, assert_success
from tests.support.inline import inline
from tests.support.fixtures import create_dialog

19
tests/wpt/web-platform-tests/webdriver/tests/support/asserts.py
View file

@ -137,3 +137,22 @@ def assert_same_element(session, a, b):
pass
raise AssertionError(message)
def assert_element_has_focus(target_element):
session = target_element.session
active_element = session.execute_script("return document.activeElement")
active_tag = active_element.property("localName")
target_tag = target_element.property("localName")
assert active_element == target_element, (
"Focussed element is <%s>, not <%s>" % (active_tag, target_tag))
def assert_move_to_coordinates(point, target, events):
for e in events:
if e["type"] != "mousemove":
assert e["pageX"] == point["x"]
assert e["pageY"] == point["y"]
assert e["target"] == target