Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 21:50:18 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision 7123012427f92f0dc38a120e6e86a75b6c03aab5

Browse source
This commit is contained in:
Ms2ger 2015-10-31 14:26:53 +01:00
parent 912359fcbd
commit b492a3e8b1
45 changed files with 688 additions and 232 deletions
Download patch file Download diff file Expand all files Collapse all files

21
tests/wpt/metadata/MANIFEST.json
View file

@ -11437,6 +11437,10 @@
"path": "IndexedDB/idbobjectstore_openCursor_invalid.htm",
"url": "/IndexedDB/idbobjectstore_openCursor_invalid.htm"
},
{
"path": "IndexedDB/idbobjectstore_openKeyCursor.htm",
"url": "/IndexedDB/idbobjectstore_openKeyCursor.htm"
},
{
"path": "IndexedDB/idbobjectstore_put.htm",
"url": "/IndexedDB/idbobjectstore_put.htm"
@ -29747,6 +29751,9 @@
{
"path": "webdriver/element_state/method_test.py"
},
{
"path": "webdriver/element_state/properties.py"
},
{
"path": "webdriver/element_state/visibility_test.py"
},
@ -29777,6 +29784,12 @@
{
"path": "webdriver/navigation/refresh-page.py"
},
{
"path": "webdriver/navigation/refresh_page.py"
},
{
"path": "webdriver/screenshot/take_screenshot.py"
},
{
"path": "webdriver/timeouts/implicit_waits_tests.py"
},
@ -29785,6 +29798,12 @@
},
{
"path": "webdriver/user_input/clear_test.py"
},
{
"path": "webdriver/windows/tabbing.py"
},
{
"path": "webdriver/windows/window_manipulation.py"
}
]
},
@ -35327,7 +35346,7 @@
}
]
},
"rev": "4b25d322ac6ed466f992669e5408b15d37d56436",
"rev": "7123012427f92f0dc38a120e6e86a75b6c03aab5",
"url_base": "/",
"version": 2
}

6
tests/wpt/metadata/html/browsers/windows/nested-browsing-contexts/frameElement.sub.html.ini
View file

@ -6,3 +6,9 @@
[The SecurityError must be thrown if the container's document does not have the same effective script origin]
expected: FAIL
[The SecurityError must be thrown if the window accesses to frameElement attribute of a Window which does not have the same effective script origin]
expected: FAIL
[The window's frameElement attribute must return null if the container's document does not have the same effective script origin]
expected: FAIL

1
tests/wpt/metadata/html/semantics/forms/the-select-element/select-ask-for-reset.html.ini
View file

@ -2,3 +2,4 @@
type: testharness
[ask for reset on node remove, non multiple.]
expected: FAIL

2
tests/wpt/metadata/mozilla-sync
View file

@ -1 +1 @@
7574a8ec72e121613cb56f2af746f858c02b7181
521a87180a85709f8f704df33537f79bd131bf71

1
tests/wpt/web-platform-tests/.gitignore vendored
View file

@ -9,3 +9,4 @@ config.json
node_modules
scratch
testharness_runner.html
webdriver/.idea

139
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_openKeyCursor.htm Normal file
View file

@ -0,0 +1,139 @@
<!DOCTYPE html>
<title>IDBObjectStore.openKeyCursor()</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script>
function store_test(func, name) {
async_test(function(t) {
var del = indexedDB.deleteDatabase(name);
del.onerror = t.unreached_func("deleteDatabase failed");
var open = indexedDB.open(name);
open.onupgradeneeded = t.step_func(function() {
var db = open.result;
var store = db.createObjectStore("store");
for (var i = 0; i < 10; ++i) {
store.put("value: " + i, i);
}
});
open.onsuccess = t.step_func(function() {
var db = open.result;
var tx = db.transaction("store");
var store = tx.objectStore("store");
func(t, db, tx, store);
});
}, name);
}
store_test(function(t, db, tx, store) {
var expected = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var actual = [];
var request = store.openKeyCursor();
request.onsuccess = t.step_func(function() {
var cursor = request.result;
if (!cursor)
return;
assert_equals(cursor.direction, "next");
assert_false("value" in cursor);
assert_equals(indexedDB.cmp(cursor.key, cursor.primaryKey), 0);
actual.push(cursor.key);
cursor.continue();
});
tx.onabort = t.unreached_func("transaction aborted");
tx.oncomplete = t.step_func(function() {
assert_array_equals(expected, actual, "keys should match");
t.done();
});
}, "IDBObjectStore.openKeyCursor() - forward iteration");
store_test(function(t, db, tx, store) {
var expected = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
var actual = [];
var request = store.openKeyCursor(null, "prev");
request.onsuccess = t.step_func(function() {
var cursor = request.result;
if (!cursor)
return;
assert_equals(cursor.direction, "prev");
assert_false("value" in cursor);
assert_equals(indexedDB.cmp(cursor.key, cursor.primaryKey), 0);
actual.push(cursor.key);
cursor.continue();
});
tx.onabort = t.unreached_func("transaction aborted");
tx.oncomplete = t.step_func(function() {
assert_array_equals(expected, actual, "keys should match");
t.done();
});
}, "IDBObjectStore.openKeyCursor() - reverse iteration");
store_test(function(t, db, tx, store) {
var expected = [4, 5, 6];
var actual = [];
var request = store.openKeyCursor(IDBKeyRange.bound(4, 6));
request.onsuccess = t.step_func(function() {
var cursor = request.result;
if (!cursor)
return;
assert_equals(cursor.direction, "next");
assert_false("value" in cursor);
assert_equals(indexedDB.cmp(cursor.key, cursor.primaryKey), 0);
actual.push(cursor.key);
cursor.continue();
});
tx.onabort = t.unreached_func("transaction aborted");
tx.oncomplete = t.step_func(function() {
assert_array_equals(expected, actual, "keys should match");
t.done();
});
}, "IDBObjectStore.openKeyCursor() - forward iteration with range");
store_test(function(t, db, tx, store) {
var expected = [6, 5, 4];
var actual = [];
var request = store.openKeyCursor(IDBKeyRange.bound(4, 6), "prev");
request.onsuccess = t.step_func(function() {
var cursor = request.result;
if (!cursor)
return;
assert_equals(cursor.direction, "prev");
assert_false("value" in cursor);
assert_equals(indexedDB.cmp(cursor.key, cursor.primaryKey), 0);
actual.push(cursor.key);
cursor.continue();
});
tx.onabort = t.unreached_func("transaction aborted");
tx.oncomplete = t.step_func(function() {
assert_array_equals(expected, actual, "keys should match");
t.done();
});
}, "IDBObjectStore.openKeyCursor() - reverse iteration with range");
store_test(function(t, db, tx, store) {
assert_throws("DataError", function() { store.openKeyCursor(NaN); },
"openKeyCursor should throw on invalid number key");
assert_throws("DataError", function() { store.openKeyCursor(new Date(NaN)); },
"openKeyCursor should throw on invalid date key");
assert_throws("DataError", function() {
var cycle = [];
cycle.push(cycle);
store.openKeyCursor(cycle);
}, "openKeyCursor should throw on invalid array key");
assert_throws("DataError", function() { store.openKeyCursor({}); },
"openKeyCursor should throw on invalid key type");
setTimeout(t.step_func(function() {
assert_throws("TransactionInactiveError", function() { store.openKeyCursor(); },
"openKeyCursor should throw if transaction is inactive");
t.done();
}), 0);
}, "IDBObjectStore.openKeyCursor() - invalid inputs");
</script>

23
tests/wpt/web-platform-tests/IndexedDB/support.js
View file

@ -1,29 +1,6 @@
var databaseName = "database";
var databaseVersion = 1;
if (!window.indexedDB)
{
if (window.msIndexedDB)
{
window.indexedDB = window.msIndexedDB;
}
else if (window.mozIndexedDB)
{
window.indexedDB = window.mozIndexedDB;
}
else if (window.webkitIndexedDB)
{
window.indexedDB = webkitIndexedDB;
IDBCursor = webkitIDBCursor;
IDBDatabaseException = webkitIDBDatabaseException;
IDBIndex = webkitIDBIndex;
IDBObjectStore = webkitIDBObjectStore;
IDBRequest = webkitIDBRequest;
IDBKeyRange = webkitIDBKeyRange;
IDBTransaction = webkitIDBTransaction;
}
}
/* Delete created databases
*
* Go through each finished test, see if it has an associated database. Close

6
tests/wpt/web-platform-tests/README.md
View file

@ -2,8 +2,10 @@ The Web Platform Tests Project [![IRC chat](https://goo.gl/6nCIks)](http://irc.w
==============================
The Web Platform Tests Project is a W3C-coordinated attempt to build a
cross-browser testsuite for the Web-platform stack. Writing tests in a
way that allows them to be run in all browsers gives browser projects
cross-browser testsuite for the Web-platform stack. However, for mainly
historic reasons, the CSS WG testsuite is in a separate repository,
[csswg-test](https://github.com/w3c/csswg-test). Writing tests in a way
that allows them to be run in all browsers gives browser projects
confidence that they are shipping software that is compatible with other
implementations, and that later implementations will be compatible with
their implementations. This in turn gives Web authors/developers

69
tests/wpt/web-platform-tests/content-security-policy/blink-contrib-2/scripthash-unicode-normalization.sub.html
View file

@ -6,37 +6,68 @@
<title>scripthash-unicode-normalization</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/content-security-policy/support/alertAssert.sub.js?alerts=%5B%22PASS%22%2C%22PASS%22%5D">
</script>
<!-- enforcing policy:
script-src 'self' 'unsafe-inline' 'sha256-xy4iRAvdlFCq+M5+4yu4B7dy0Kc2FfljmZO4Jkj3Yhw='; connect-src 'self';
script-src 'self' 'nonce-nonceynonce' 'sha256-dWTP4Di8KBjaiXvQ5mRquI9OoBSo921ahYxLfYSiuT8='; connect-src 'self';
-->
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<!-- The following two scripts contain two separate code points (U+00C5
and U+212B, respectively) which, depending on your text editor, might be
rendered the same. However, their difference is important as they should
be NFC normalized to the same code point, thus they should hash to the
same value.-->
<script>
'Å';
alert_assert('PASS');
</script>
<script>
'Å';
alert_assert('PASS');
</script>
</head>
<body>
<!-- The following two scripts contain two separate code points (U+00C5
and U+212B, respectively) which, depending on your text editor, might be
rendered the same.However, their difference is important because, under
NFC normalization, they would become the same code point, which would be
against the spec. This test, therefore, validates that the scripts have
*different* hash values. -->
<script nonce="nonceynonce">
var matchingContent = 'Å';
var nonMatchingContent = 'Å';
// This script should have a hash value of
// sha256-9UFeeZbvnMa0tLNu76v96T4Hh+UtDWHm2lPQJoTWb9c=
var scriptContent1 = "window.finish('" + matchingContent + "');";
// This script should have a hash value of
// sha256-iNjjXUXds31FFvkAmbC74Sxnvreug3PzGtu16udQyqM=
var scriptContent2 = "window.finish('" + nonMatchingContent + "');";
var script1 = document.createElement('script');
script1.innerHTML = scriptContent1;
var script2 = document.createElement('script');
script2.innerHTML = scriptContent2;
script1.test = async_test("Inline script with hash in CSP");
script2.test = async_test("Inline script without hash in CSP");
var failure = function() {
assert_unreached();
}
window.finish = function(content) {
if (content == matchingContent) {
script1.test.step(function() {
script1.test.done();
});
} else {
assert_unreached();
}
}
script1.onerror = failure;
script2.onerror = script2.test.step_func(function() {
script2.test.done();
});
document.body.appendChild(script1);
document.body.appendChild(script2);
</script>
<p>
This tests Unicode normalization. While appearing the same, the strings in the scripts are different Unicode points, but through normalization, should be the same when the hash is taken.
</p>
<div id="log"></div>
<script async defer src="../support/checkReport.sub.js?reportExists=false"></script>
<script async defer src="../support/checkReport.sub.js?reportExists=true"></script>
</body>
</html>

2
tests/wpt/web-platform-tests/content-security-policy/blink-contrib-2/scripthash-unicode-normalization.sub.html.sub.headers
View file

@ -3,4 +3,4 @@ Cache-Control: no-store, no-cache, must-revalidate
Cache-Control: post-check=0, pre-check=0, false
Pragma: no-cache
Set-Cookie: scripthash-unicode-normalization={{$id:uuid()}}; Path=/content-security-policy/blink-contrib-2
Content-Security-Policy: script-src 'self' 'sha256-xy4iRAvdlFCq+M5+4yu4B7dy0Kc2FfljmZO4Jkj3Yhw='; connect-src 'self'; report-uri /content-security-policy/support/report.py?op=put&reportID={{$id}}
Content-Security-Policy: script-src 'self' 'nonce-nonceynonce' 'sha256-9UFeeZbvnMa0tLNu76v96T4Hh+UtDWHm2lPQJoTWb9c='; connect-src 'self'; report-uri /content-security-policy/support/report.py?op=put&reportID={{$id}}

35
tests/wpt/web-platform-tests/html/browsers/windows/nested-browsing-contexts/frameElement.sub.html
View file

@ -7,7 +7,8 @@
<script>
var t1 = async_test("The window's frameElement attribute must return its container element if it is a nested browsing context");
var t2 = async_test("The SecurityError must be thrown if the container's document does not have the same effective script origin");
var t2 = async_test("The SecurityError must be thrown if the window accesses to frameElement attribute of a Window which does not have the same effective script origin");
var t3 = async_test("The window's frameElement attribute must return null if the container's document does not have the same effective script origin");
function on_load() {
t1.step(function () {
@ -17,9 +18,9 @@ function on_load() {
"The frameElement attribute should be the object element.");
assert_equals(window["win3"].frameElement, document.getElementById("emb"),
"The frameElement attribute should be the embed element.");
assert_equals(document.getElementById("fr3").contentWindow[0].frameElement,
document.getElementById("fr3").contentDocument.getElementById("f1"),
"The frameElement attribute should be the frame element in 'test.html'.");
assert_equals(document.getElementById("fr4").contentWindow[0].frameElement,
document.getElementById("fr4").contentDocument.getElementById("f1"),
"The frameElement attribute should be the frame element in 'test.html'.");
});
t1.done();
@ -28,23 +29,39 @@ function on_load() {
"The SecurityError exception should be thrown.");
});
t2.done();
t3.step(function () {
document.getElementById("fr5").contentWindow.postMessage(null, "*");
});
window.addEventListener("message", function (event) {
var data = JSON.parse(event.data);
if (data.name == "testcase3") {
t3.step(function () {
assert_equals(data.result, "window.frameElement = null",
"The frameElement attribute shoudl be null.");
});
t3.done();
}
}, false);
}
</script>
<body onload="on_load()">
<div id="log"></div>
<iframe id="fr1"></iframe>
<iframe id="fr2" src="test.html"></iframe>
<iframe id="fr2" src="test.html"></iframe> <!-- cross origin -->
<iframe id="fr3" src="" style="display:none"></iframe>
<object id="obj" name="win2" type="text/html" data="about:blank"></object>
<embed id="emb" name="win3" type="image/svg+xml" src="/images/green.svg" />
<iframe id="fr4" src="test.html"></iframe> <!-- same origin -->
<iframe id="fr5" src="testcase3.html"></iframe> <!-- cross origin -->
<script>
setup(function () {
var src = "http://{{domains[www1]}}:{{ports[http][0]}}";
src += document.location.pathname.substring(0, document.location.pathname.lastIndexOf("/") + 1);
src += "test.html";
document.getElementById("fr2").src = src;
var src_base = "http://{{domains[www1]}}:{{ports[http][0]}}";
src_base += document.location.pathname.substring(0, document.location.pathname.lastIndexOf("/") + 1);
document.getElementById("fr2").src = src_base + "test.html";
document.getElementById("fr5").src = src_base + "testcase3.html";
});
test(function () {

14
tests/wpt/web-platform-tests/html/browsers/windows/nested-browsing-contexts/testcase3.html Normal file
View file

@ -0,0 +1,14 @@
<!DOCTYPE html>
<meta charset="utf-8"/>
<title>Testcase 3: frameElement attribute must return null if the container\'s document does not have the same effective script origin</title>
<script>
window.addEventListener("message", function (event) {
try {
var result = "window.frameElement = " + window.frameElement;
} catch (e) {
result = e.message;
}
event.source.postMessage(JSON.stringify({name: "testcase3", result: result}),
"*");
}, false);
</script>

2
tests/wpt/web-platform-tests/resources/testharness.js
View file

@ -1176,6 +1176,7 @@ policies and contribution forms [3].
NO_MODIFICATION_ALLOWED_ERR: 'NoModificationAllowedError',
NOT_FOUND_ERR: 'NotFoundError',
NOT_SUPPORTED_ERR: 'NotSupportedError',
INUSE_ATTRIBUTE_ERR: 'InUseAttributeError',
INVALID_STATE_ERR: 'InvalidStateError',
SYNTAX_ERR: 'SyntaxError',
INVALID_MODIFICATION_ERR: 'InvalidModificationError',
@ -1202,6 +1203,7 @@ policies and contribution forms [3].
NoModificationAllowedError: 7,
NotFoundError: 8,
NotSupportedError: 9,
InUseAttributeError: 10,
InvalidStateError: 11,
SyntaxError: 12,
InvalidModificationError: 13,

17
tests/wpt/web-platform-tests/webdriver/base_test.py
View file

@ -10,7 +10,7 @@ repo_root = os.path.abspath(os.path.join(__file__, "../.."))
sys.path.insert(1, os.path.join(repo_root, "tools", "webdriver"))
sys.path.insert(1, os.path.join(repo_root, "tools", "wptserve"))
from wptserve import server
from webdriver.driver import WebDriver
from selenium import webdriver
class WebDriverBaseTest(unittest.TestCase):
@ -33,9 +33,10 @@ def create_driver():
config = ConfigParser.ConfigParser()
config.read('webdriver.cfg')
section = os.environ.get("WD_BROWSER", 'firefox')
url = 'http://127.0.0.1:4444/wd/hub'
if config.has_option(section, 'url'):
url = config.get(section, "url")
else:
url = 'http://127.0.0.1:4444/wd/hub'
capabilities = None
if config.has_option(section, 'capabilities'):
try:
@ -45,5 +46,15 @@ def create_driver():
mode = 'compatibility'
if config.has_option(section, 'mode'):
mode = config.get(section, 'mode')
if section == 'firefox':
driver = webdriver.Firefox()
elif section == 'chrome':
driver = webdriver.Chrome()
elif section == 'edge':
driver = webdriver.Remote()
elif section == 'ie':
driver = webdriver.Ie()
elif section == 'selendroid':
driver = webdriver.Android()
return WebDriver(url, {}, capabilities, mode)
return driver

26
tests/wpt/web-platform-tests/webdriver/cookie/cookie_test.py
View file

@ -4,7 +4,7 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions
from selenium.common import exceptions
class CookieTest(base_test.WebDriverBaseTest):
@ -12,20 +12,14 @@ class CookieTest(base_test.WebDriverBaseTest):
self.driver.get(self.webserver.where_is("cookie/res/cookie_container.html"))
def test_can_create_a_well_formed_cookie( self ):
name = 'foo'
value = 'bar'
self.driver.add_cookie({ 'name': name, 'value': value })
self.driver.add_cookie({'name': 'foo', 'value': 'bar'})
def test_cookies_should_allow_secure_to_be_set( self ):
name = 'foo'
value = 'bar'
secure = True
self.driver.add_cookie({ 'name': name,
'value': value,
'path': '/',
'secure': secure})
self.driver.add_cookie({'name': name,
'value': 'bar',
'path': '/',
'secure': (True)})
self.assertTrue(self.driver.get_cookie(name)[0]['secure'])
def test_secure_defaults_to_false( self ):
@ -39,10 +33,8 @@ class CookieTest(base_test.WebDriverBaseTest):
def test_should_throw_an_exception_when_semicolon_exists_in_the_cookie_attribute(self):
invalid_name = 'foo;bar'
value = 'foobar'
try:
self.driver.add_cookie({ 'name': invalid_name, 'value': value })
self.driver.add_cookie({'name': invalid_name, 'value': 'foobar'})
self.fail( 'should have thrown exceptions.' )
except exceptions.UnableToSetCookieException:
@ -51,10 +43,8 @@ class CookieTest(base_test.WebDriverBaseTest):
pass
def test_should_throw_an_exception_the_name_is_null(self):
val = 'foobar'
try:
self.driver.add_cookie({ 'name': None, 'value': val })
self.driver.add_cookie({'name': None, 'value': 'foobar'})
self.fail( 'should have thrown exceptions.' )
except exceptions.UnableToSetCookieException:

29
tests/wpt/web-platform-tests/webdriver/element_location/element_location_test.py
View file

@ -5,16 +5,15 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
class ElementLocationTest(base_test.WebDriverBaseTest):
def test_find_element_by_name(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html"))
e = self.driver.find_element_by_css("*[name='name']")
e = self.driver.find_element_by_name("name")
self.assertEquals("name", e.text)
def test_find_element_by_css_selector(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html"))
e = self.driver.find_element_by_css("#id")
e = self.driver.find_element_by_css_selector("#id")
self.assertEquals("id", e.text)
def test_find_element_by_link_text(self):
@ -32,6 +31,30 @@ class ElementLocationTest(base_test.WebDriverBaseTest):
e = self.driver.find_element_by_xpath("//*[@id='id']")
self.assertEquals("id", e.text)
def test_find_elements_by_name(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html"))
e = self.driver.find_elements_by_name("name")
self.assertEquals("name", e[0].text)
def test_find_elements_by_css_selector(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html"))
e = self.driver.find_elements_by_css_selector("#id")
self.assertEquals("id", e[0].text)
def test_find_elements_by_link_text(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html"))
e = self.driver.find_elements_by_link_text("link text")
self.assertEquals("link text", e[0].text)
def test_find_elements_by_partial_link_text(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html"))
e = self.driver.find_elements_by_partial_link_text("link tex")
self.assertEquals("link text", e[0].text)
def test_find_elements_by_xpath(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html"))
e = self.driver.find_elements_by_xpath("//*[@id='id']")
self.assertEquals("id", e[0].text)
if __name__ == "__main__":
unittest.main()

22
tests/wpt/web-platform-tests/webdriver/element_state/method_test.py
View file

@ -9,12 +9,12 @@ import base_test
class GetElementAttributeTest(base_test.WebDriverBaseTest):
def test_get_element_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-id-attribute.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
self.assertEqual("myId", el.get_attribute("id"))
def test_style_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-style-attribute.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
expected_style = """
font-family: \"Gill Sans Extrabold\",Helvetica,sans-serif;
line-height: 1.2; font-weight: bold;
@ -23,47 +23,47 @@ class GetElementAttributeTest(base_test.WebDriverBaseTest):
def test_color_serialization_of_style_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-color-style-attribute.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
self.assertEqual("color: rgba(255, 0, 0, 1.0);", el.get_attribute("style"))
def test_true_if_boolean_attribute_present(self):
self.driver.get(self.webserver.where_is("element_state/res/input-with-checked-attribute.html"))
el = self.driver.find_element_by_css("input")
el = self.driver.find_element_by_css_selector("input")
self.assertEqual("true", el.get_attribute("checked"))
def test_none_if_boolean_attribute_absent(self):
self.driver.get(self.webserver.where_is("element_state/res/input-without-checked-attribute.html"))
el = self.driver.find_element_by_css("input")
el = self.driver.find_element_by_css_selector("input")
self.assertIsNone(el.get_attribute("checked"))
def test_option_with_attribute_value(self):
self.driver.get(self.webserver.where_is("element_state/res/option-with-value-attribute.html"))
el = self.driver.find_element_by_css("option")
el = self.driver.find_element_by_css_selector("option")
self.assertEqual("value1", el.get_attribute("value"))
def test_option_without_value_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/option-without-value-attribute.html"))
el = self.driver.find_element_by_css("option")
el = self.driver.find_element_by_css_selector("option")
self.assertEqual("Value 1", el.get_attribute("value"))
def test_a_href_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/a-with-href-attribute.html"))
el = self.driver.find_element_by_css("a")
el = self.driver.find_element_by_css_selector("a")
self.assertEqual("http://web-platform.test:8000/path#fragment", el.get_attribute("href"))
def test_img_src_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/img-with-src-attribute.html"))
el = self.driver.find_element_by_css("img")
el = self.driver.find_element_by_css_selector("img")
self.assertEqual("http://web-platform.test:8000/images/blue.png", el.get_attribute("src"))
def test_custom_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-custom-attribute.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
self.assertEqual("attribute value", el.get_attribute("webdriver-custom-attribute"))
def test_attribute_not_present(self):
self.driver.get(self.webserver.where_is("element_state/res/element-without-attribute.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
self.assertIsNone(el.get_attribute("class"))

17
tests/wpt/web-platform-tests/webdriver/element_state/properties.py Normal file
View file

@ -0,0 +1,17 @@
import os
import sys
import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
class GetElementPropertiesTest(base_test.WebDriverBaseTest):
def test_get_element_text(self):
self.driver.get(self.webserver.where_is("element_state/res/elements_text.html"))
e = self.driver.find_element_by_name("name")
self.assertEquals("name", e.text)
if __name__ == "__main__":
unittest.main()

10
tests/wpt/web-platform-tests/webdriver/element_state/res/elements_text.html Normal file
View file

@ -0,0 +1,10 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>Element location</title>
<body>
<div id="id">id</div>
<div id="name" name="name">name</div>
<a id="link">link text</a>
</body>

106
tests/wpt/web-platform-tests/webdriver/element_state/visibility_test.py
View file

@ -4,41 +4,41 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions
from selenium.common import exceptions
class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
def test_0x0_pixel_element_is_not_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/0x0-pixels.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
self.assertFalse(el.is_displayed())
def test_0x0_pixel_text_node_is_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/0x0-pixels-text-node.html"))
el = self.driver.find_element_by_css("p")
el = self.driver.find_element_by_css_selector("p")
self.assertTrue(el.is_displayed())
def test_1x1_pixel_element(self):
self.driver.get(self.webserver.where_is("element_state/res/1x1-pixels.html"))
el = self.driver.find_element_by_css("p")
el = self.driver.find_element_by_css_selector("p")
self.assertTrue(el.is_displayed())
def test_zero_sized_element_is_shown_if_decendant_has_size(self):
self.driver.get(self.webserver.where_is("element_state/res/zero-sized-element-with-sizable-decendant.html"))
parent = self.driver.find_element_by_css("#parent")
child = self.driver.find_element_by_css("#child")
parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css_selector("#child")
self.assertTrue(parent.is_displayed())
self.assertTrue(child.is_displayed())
def test_input_type_hidden_is_never_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/input-type-hidden.html"))
input = self.driver.find_element_by_css("input")
input = self.driver.find_element_by_css_selector("input")
self.assertFalse(input.is_displayed())
def test_input_morphs_into_hidden(self):
self.driver.get(self.webserver.where_is("element_state/res/input-morphs-into-hidden.html"))
input = self.driver.find_element_by_css("input")
input = self.driver.find_element_by_css_selector("input")
self.assertFalse(input.is_displayed())
def test_parent_node_visible_when_all_children_are_absolutely_positioned_and_overflow_is_hidden(self):
@ -51,10 +51,10 @@ class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
self.driver.get(self.webserver.where_is("element_state/res/absolute-children-ancestor-hidden-overflow.html"))
children = self.driver.find_elements_by_css(".child")
children = self.driver.find_elements_by_css_selector(".child")
assert all(child.is_displayed() for child in children)
parent = self.driver.find_element_by_css("#parent")
parent = self.driver.find_element_by_css_selector("#parent")
assert parent.is_displayed()
def test_element_hidden_by_overflow_x_is_not_visible(self):
@ -66,8 +66,8 @@ class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
for page in pages:
self.driver.get(self.webserver.where_is(page))
right = self.driver.find_element_by_css("#right")
bottom_right = self.driver.find_element_by_css("#bottom-right")
right = self.driver.find_element_by_css_selector("#right")
bottom_right = self.driver.find_element_by_css_selector("#bottom-right")
self.assertFalse(right.is_displayed())
self.assertFalse(bottom_right.is_displayed())
@ -81,8 +81,8 @@ class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
for page in pages:
self.driver.get(self.webserver.where_is(page))
bottom = self.driver.find_element_by_css("#bottom")
bottom_right = self.driver.find_element_by_css("#bottom-right")
bottom = self.driver.find_element_by_css_selector("#bottom")
bottom_right = self.driver.find_element_by_css_selector("#bottom-right")
self.assertFalse(bottom.is_displayed())
self.assertFalse(bottom_right.is_displayed())
@ -104,78 +104,78 @@ class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
def test_element_outside_viewport(self):
self.driver.get(self.webserver.where_is("element_state/res/element-outside-viewport.html"))
hidden = self.driver.find_element_by_css("div")
hidden = self.driver.find_element_by_css_selector("div")
self.assertFalse(hidden.is_displayed())
def test_element_dynamically_moved_outside_viewport(self):
self.driver.get(self.webserver.where_is("element_state/res/element-dynamically-moved-outside-viewport.html"))
hidden = self.driver.find_element_by_css("div")
hidden = self.driver.find_element_by_css_selector("div")
self.assertFalse(hidden.is_displayed())
def test_element_hidden_by_other_element(self):
self.driver.get(self.webserver.where_is("element_state/res/element-hidden-by-other-element.html"))
overlay = self.driver.find_element_by_css("#overlay")
hidden = self.driver.find_element_by_css("#hidden")
overlay = self.driver.find_element_by_css_selector("#overlay")
hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertTrue(overlay.is_displayed())
self.assertFalse(hidden.is_displayed())
def test_element_partially_hidden_by_other_element(self):
self.driver.get(self.webserver.where_is("element_state/res/element-partially-hidden-by-other-element.html"))
partial = self.driver.find_element_by_css("#partial")
partial = self.driver.find_element_by_css_selector("#partial")
self.assertTrue(partial.is_displayed())
def test_element_hidden_by_z_index(self):
self.driver.get(self.webserver.where_is("element_state/res/element-hidden-by-z-index.html"))
overlay = self.driver.find_element_by_css("#overlay")
hidden = self.driver.find_element_by_css("#hidden")
overlay = self.driver.find_element_by_css_selector("#overlay")
hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertTrue(overlay.is_displayed())
self.assertFalse(hidden.is_displayed())
def test_element_moved_outside_viewport_by_transform(self):
self.driver.get(self.webserver.where_is("element_state/res/element-moved-outside-viewport-by-transform.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
self.assertFalse(el.is_displayed())
def test_element_moved_behind_other_element_by_transform(self):
self.driver.get(self.webserver.where_is("element_state/res/element-moved-behind-other-element-by-transform.html"))
overlay = self.driver.find_element_by_css("#overlay")
hidden = self.driver.find_element_by_css("#hidden")
overlay = self.driver.find_element_by_css_selector("#overlay")
hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertTrue(overlay.is_displayed())
self.assertFalse(hidden.is_displayed())
def test_text_with_same_color_as_background(self):
self.driver.get(self.webserver.where_is("element_state/res/text-with-same-color-as-background.html"))
p = self.driver.find_element_by_css("p")
p = self.driver.find_element_by_css_selector("p")
self.assertFalse(p.is_displayed())
def test_text_with_same_color_as_parent_background(self):
self.driver.get(self.webserver.where_is("element_state/res/text-with-same-color-as-parent-background.html"))
p = self.driver.find_element_by_css("p")
p = self.driver.find_element_by_css_selector("p")
self.assertFalse(p.is_displayed())
def test_text_with_matching_color_and_background(self):
self.driver.get(self.webserver.where_is("element_state/res/text-with-matching-color-and-background.html"))
p = self.driver.find_element_by_css("p")
p = self.driver.find_element_by_css_selector("p")
self.assertTrue(p.is_displayed())
def test_element_with_same_color_as_background(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-same-color-as-background.html"))
el = self.driver.find_element_by_css("div")
el = self.driver.find_element_by_css_selector("div")
self.assertFalse(el.is_displayed())
def test_element_with_same_color_as_parent_background(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-same-color-as-parent-background.html"))
hidden = self.driver.find_element_by_css("#hidden")
hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertFalse(hidden.is_displayed())
class BodyElementIsAlwaysDisplayedTest(base_test.WebDriverBaseTest):
def assert_body_is_displayed_on(self, page):
self.driver.get(self.webserver.where_is(page))
body = self.driver.find_element_by_css("body")
body = self.driver.find_element_by_css_selector("body")
assert body.is_displayed()
def test_implicit(self):
@ -194,86 +194,86 @@ class BodyElementIsAlwaysDisplayedTest(base_test.WebDriverBaseTest):
class DisplayTest(base_test.WebDriverBaseTest):
def test_display_block(self):
self.driver.get(self.webserver.where_is("element_state/res/display-block.html"))
el = self.driver.find_element_by_css("p")
el = self.driver.find_element_by_css_selector("p")
self.assertTrue(el.is_displayed())
def test_display_none(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none.html"))
el = self.driver.find_element_by_css("p")
el = self.driver.find_element_by_css_selector("p")
self.assertFalse(el.is_displayed())
def test_display_none_hides_child_node(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-child.html"))
parent = self.driver.find_element_by_css("#parent")
child = self.driver.find_element_by_css("#child")
parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed())
def test_display_none_hides_child_node_link(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-child-link.html"))
child = self.driver.find_element_by_css("#child")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(child.is_displayed())
def test_display_none_hides_child_node_paragraph(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-child-paragraph.html"))
child = self.driver.find_element_by_css("#child")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(child.is_displayed())
def test_display_none_on_parent_takes_presedence(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-parent-presedence.html"))
child = self.driver.find_element_by_css("#child")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(child.is_displayed())
def test_display_none_on_parent_takes_presedence_over_visibility_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-parent-presedence-visibility.html"))
child = self.driver.find_element_by_css("#child")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(child.is_displayed())
def test_display_none_hidden_dynamically(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-dynamic.html"))
hidden = self.driver.find_element_by_css("#hidden")
hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertFalse(hidden.is_displayed())
class VisibilityTest(base_test.WebDriverBaseTest):
def test_element_state_hidden(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-hidden.html"))
el = self.driver.find_element_by_css("p")
el = self.driver.find_element_by_css_selector("p")
self.assertFalse(el.is_displayed())
def test_element_state_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-visible.html"))
el = self.driver.find_element_by_css("p")
el = self.driver.find_element_by_css_selector("p")
self.assertTrue(el.is_displayed())
def test_visibility_hidden_hides_child_node(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child.html"))
parent = self.driver.find_element_by_css("#parent")
child = self.driver.find_element_by_css("#child")
parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed())
def test_visibility_hidden_hides_child_node_link(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child-link.html"))
parent = self.driver.find_element_by_css("#parent")
child = self.driver.find_element_by_css("#child")
parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed())
def test_visibility_hidden_hides_child_node_paragraph(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child-paragraph.html"))
parent = self.driver.find_element_by_css("#parent")
child = self.driver.find_element_by_css("#child")
parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed())
def test_visibility_hidden_on_child_takes_precedence(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child-presedence.html"))
child = self.driver.find_element_by_css("#child")
child = self.driver.find_element_by_css_selector("#child")
self.assertTrue(child.is_displayed())
def test_visibility_hidden_on_parent_takes_precedence_over_display_block(self):
@ -284,33 +284,33 @@ class VisibilityTest(base_test.WebDriverBaseTest):
def test_should_show_element_not_visible_with_hidden_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/hidden.html"))
singleHidden = self.driver.find_element_by_css('#singleHidden')
singleHidden = self.driver.find_element_by_css_selector('#singleHidden')
self.assertFalse(singleHidden.is_displayed())
def test_should_show_element_not_visible_when_parent_element_has_hidden_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/hidden.html"))
child = self.driver.find_element_by_css('#child')
child = self.driver.find_element_by_css_selector('#child')
self.assertFalse(child.is_displayed())
class VisibilityInteractionTest(base_test.WebDriverBaseTest):
def test_input_hidden_is_unclickable(self):
self.driver.get(self.webserver.where_is("element_state/res/input-type-hidden-unclickable.html"))
input = self.driver.find_element_by_css("input")
input = self.driver.find_element_by_css_selector("input")
with self.assertRaises(exceptions.ElementNotVisibleException):
input.click()
def test_hidden_input_checkbox_is_untogglable(self):
self.driver.get(self.webserver.where_is("element_state/res/hidden-input-type-checkbox-untogglable.html"))
checkbox = self.driver.find_element_by_css("input")
checkbox = self.driver.find_element_by_css_selector("input")
with self.assertRaises(exceptions.ElementNotVisibleException):
checkbox.click()
def test_typing_in_hidden_input_is_impossible(self):
self.driver.get(self.webserver.where_is("element_state/res/hidden-input-type-text-writing.html"))
textfield = self.driver.find_element_by_css("input")
textfield = self.driver.find_element_by_css_selector("input")
with self.assertRaises(exceptions.ElementNotVisibleException):
textfield.send_keys("Koha is a popular Indian cheese")

1
tests/wpt/web-platform-tests/webdriver/javascript/execute_script_test.py
View file

@ -4,6 +4,7 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from selenium.webdriver.remote.webelement import WebElement
class ExecuteScriptTest(base_test.WebDriverBaseTest):

7
tests/wpt/web-platform-tests/webdriver/modal/alerts_quit_test.py
View file

@ -4,16 +4,17 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions, wait
from selenium.common import exceptions
from selenium.webdriver.support import wait
class AlertsQuitTest(base_test.WebDriverBaseTest):
def setUp(self):
self.wait = wait.WebDriverWait(self.driver, 5, ignored_exceptions=[exceptions.NoSuchAlertException])
self.wait = wait.WebDriverWait(self.driver, 5, ignored_exceptions=[exceptions.NoAlertPresentException])
self.driver.get(self.webserver.where_is('modal/res/alerts.html'))
def test_can_quit_when_an_alert_is_present(self):
self.driver.find_element_by_css('#alert').click()
self.driver.find_element_by_css_selector('#alert').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
self.driver.quit()
with self.assertRaises(Exception):

87
tests/wpt/web-platform-tests/webdriver/modal/alerts_test.py
View file

@ -4,144 +4,145 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions, wait
from selenium.common import exceptions
from selenium.webdriver.support import wait
class AlertsTest(base_test.WebDriverBaseTest):
def setUp(self):
self.wait = wait.WebDriverWait(self.driver, 5, ignored_exceptions = [exceptions.NoSuchAlertException])
self.wait = wait.WebDriverWait(self.driver, 5, ignored_exceptions = [exceptions.NoAlertPresentException])
self.driver.get(self.webserver.where_is('modal/res/alerts.html'))
def tearDown(self):
try:
self.driver.switch_to_alert().dismiss()
except exceptions.NoSuchAlertException:
except exceptions.NoAlertPresentException:
pass
# Alerts
def test_should_allow_user_to_accept_an_alert(self):
self.driver.find_element_by_css('#alert').click()
self.driver.find_element_by_css_selector('#alert').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
self.driver.get_current_url()
self.driver.current_url
def test_should_allow_user_to_accept_an_alert_with_no_text(self):
self.driver.find_element_by_css('#empty-alert').click()
self.driver.find_element_by_css_selector('#empty-alert').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
self.driver.get_current_url()
self.driver.current_url
def test_should_allow_user_to_dismiss_an_alert(self):
self.driver.find_element_by_css('#alert').click()
self.driver.find_element_by_css_selector('#alert').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss()
self.driver.get_current_url()
self.driver.current_url
def test_should_allow_user_to_get_text_of_an_alert(self):
self.driver.find_element_by_css('#alert').click()
self.driver.find_element_by_css_selector('#alert').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
value = alert.get_text()
value = alert.text
alert.accept()
self.assertEquals('cheese', value)
def test_setting_the_value_of_an_alert_throws(self):
self.driver.find_element_by_css('#alert').click()
self.driver.find_element_by_css_selector('#alert').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
with self.assertRaises(exceptions.ElementNotVisibleException):
alert.send_keys('cheese')
alert.accept()
def test_alert_should_not_allow_additional_commands_if_dismissed(self):
self.driver.find_element_by_css('#alert').click()
self.driver.find_element_by_css_selector('#alert').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
with self.assertRaises(exceptions.NoSuchAlertException):
alert.get_text()
with self.assertRaises(exceptions.NoAlertPresentException):
alert.text
# Prompts
def test_should_allow_user_to_accept_a_prompt(self):
self.driver.find_element_by_css('#prompt').click()
self.driver.find_element_by_css_selector('#prompt').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
self.wait.until(lambda x: x.find_element_by_css('#text').text == '')
self.wait.until(lambda x: x.find_element_by_css_selector('#text').text == '')
def test_should_allow_user_to_dismiss_a_prompt(self):
self.driver.find_element_by_css('#prompt').click()
self.driver.find_element_by_css_selector('#prompt').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss()
self.wait.until(lambda x: x.find_element_by_css('#text').text == 'null')
self.wait.until(lambda x: x.find_element_by_css_selector('#text').text == 'null')
def test_should_allow_user_to_set_the_value_of_a_prompt(self):
self.driver.find_element_by_css('#prompt').click()
self.driver.find_element_by_css_selector('#prompt').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.send_keys('cheese')
alert.accept()
self.wait.until(lambda x: x.find_element_by_css('#text').text == 'cheese')
self.wait.until(lambda x: x.find_element_by_css_selector('#text').text == 'cheese')
def test_should_allow_user_to_get_text_of_a_prompt(self):
self.driver.find_element_by_css('#prompt').click()
self.driver.find_element_by_css_selector('#prompt').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
value = alert.get_text()
value = alert.text
alert.accept()
self.assertEquals('Enter something', value)
def test_prompt_should_not_allow_additional_commands_if_dismissed(self):
self.driver.find_element_by_css('#prompt').click()
self.driver.find_element_by_css_selector('#prompt').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
with self.assertRaises(exceptions.NoSuchAlertException):
alert.get_text()
with self.assertRaises(exceptions.NoAlertPresentException):
alert.text
def test_prompt_should_use_default_value_if_no_keys_sent(self):
self.driver.find_element_by_css('#prompt-with-default').click()
self.driver.find_element_by_css_selector('#prompt-with-default').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
self.wait.until(lambda x: x.find_element_by_css('#text').text == 'This is a default value')
self.wait.until(lambda x: x.find_element_by_css_selector('#text').text == 'This is a default value')
def test_prompt_should_have_null_value_if_dismissed(self):
self.driver.find_element_by_css('#prompt-with-default').click()
self.driver.find_element_by_css_selector('#prompt-with-default').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss()
self.wait.until(lambda x: x.find_element_by_css('#text').text == 'null')
self.wait.until(lambda x: x.find_element_by_css_selector('#text').text == 'null')
# Confirmations
def test_should_allow_user_to_accept_a_confirm(self):
self.driver.find_element_by_css('#confirm').click()
self.driver.find_element_by_css_selector('#confirm').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
self.wait.until(lambda x: x.find_element_by_css('#text').text == 'true')
self.wait.until(lambda x: x.find_element_by_css_selector('#text').text == 'true')
def test_should_allow_user_to_dismiss_a_confirm(self):
self.driver.find_element_by_css('#confirm').click()
self.driver.find_element_by_css_selector('#confirm').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss()
self.wait.until(lambda x: x.find_element_by_css('#text').text == 'false')
self.wait.until(lambda x: x.find_element_by_css_selector('#text').text == 'false')
def test_setting_the_value_of_a_confirm_throws(self):
self.driver.find_element_by_css('#confirm').click()
self.driver.find_element_by_css_selector('#confirm').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
with self.assertRaises(exceptions.ElementNotVisibleException):
alert.send_keys('cheese')
alert.accept()
def test_should_allow_user_to_get_text_of_a_confirm(self):
self.driver.find_element_by_css('#confirm').click()
self.driver.find_element_by_css_selector('#confirm').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
value = alert.get_text()
value = alert.text
alert.accept()
self.assertEquals('cheese', value)
def test_confirm_should_not_allow_additional_commands_if_dismissed(self):
self.driver.find_element_by_css('#confirm').click()
self.driver.find_element_by_css_selector('#confirm').click()
alert = self.wait.until(lambda x: x.switch_to_alert())
alert.accept()
with self.assertRaises(exceptions.NoSuchAlertException):
alert.get_text()
with self.assertRaises(exceptions.NoAlertPresentException):
alert.text
"""
def test_switch_to_missing_alert_fails(self):
with self.assertRaises(exceptions.NoSuchAlertException):
with self.assertRaises(exceptions.NoAlertPresentException):
self.driver.switch_to_alert()
"""
if __name__ == '__main__':
unittest.main()

2
tests/wpt/web-platform-tests/webdriver/navigation/auth_tests.py
View file

@ -5,7 +5,7 @@ import ConfigParser
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions
from selenium.common import exceptions
from wptserve import server
from wptserve.router import any_method
from wptserve.handlers import basic_auth_handler

10
tests/wpt/web-platform-tests/webdriver/navigation/forward.py
View file

@ -11,12 +11,12 @@ class ForwardTest(base_test.WebDriverBaseTest):
def test_forward(self):
self.driver.get(self.webserver.where_is('navigation/res/forwardStart.html'))
self.driver.get(self.webserver.where_is('navigation/res/forwardNext.html'))
nextbody = self.driver.find_element_by_css("body").text
self.driver.go_back()
currbody = self.driver.find_element_by_css("body").text
nextbody = self.driver.find_element_by_css_selector("body").text
self.driver.back()
currbody = self.driver.find_element_by_css_selector("body").text
self.assertNotEqual(nextbody, currbody)
self.driver.go_forward()
currbody = self.driver.find_element_by_css("body").text
self.driver.forward()
currbody = self.driver.find_element_by_css_selector("body").text
self.assertEqual(nextbody, currbody)

6
tests/wpt/web-platform-tests/webdriver/navigation/forwardToNothing.py
View file

@ -10,9 +10,9 @@ class ForwardToNothingTest(base_test.WebDriverBaseTest):
# Get a static page that must be the same upon refresh
def test_forwardToNothing(self):
self.driver.get(self.webserver.where_is('navigation/forwardStart.html'))
body = self.driver.find_element_by_css("body").text
self.driver.go_forward()
currbody = self.driver.find_element_by_css("body").text
body = self.driver.find_element_by_css_selector("body").text
self.driver.forward()
currbody = self.driver.find_element_by_css_selector("body").text
self.assertEqual(body, currbody)

10
tests/wpt/web-platform-tests/webdriver/navigation/get_from_http_test.py
View file

@ -10,7 +10,7 @@ class GetFromHttpTest(base_test.WebDriverBaseTest):
def testGetUrlWithNoRedirectionOverHttp(self):
page = self.webserver.where_is('navigation/res/empty.html')
self.driver.get(page)
url = self.driver.get_current_url()
url = self.driver.current_url
self.assertEquals(page, url)
@ -18,7 +18,7 @@ class GetFromHttpTest(base_test.WebDriverBaseTest):
page = self.webserver.where_is('navigation/redirect')
self.driver.get(page)
expected = self.webserver.where_is('navigation/res/empty.html')
url = self.driver.get_current_url()
url = self.driver.current_url
self.assertEquals(expected, url)
@ -26,7 +26,7 @@ class GetFromHttpTest(base_test.WebDriverBaseTest):
page = self.webserver.where_is('navigation/res/instant-meta-redirect.html')
self.driver.get(page)
expected = self.webserver.where_is('navigation/res/empty.html')
url = self.driver.get_current_url()
url = self.driver.current_url
self.assertEquals(expected, url)
@ -34,14 +34,14 @@ class GetFromHttpTest(base_test.WebDriverBaseTest):
page = self.webserver.where_is('navigation/res/1s-meta-redirect.html')
self.driver.get(page)
expected = self.webserver.where_is('navigation/res/empty.html')
url = self.driver.get_current_url()
url = self.driver.current_url
self.assertEquals(expected, url)
def testGetWillNotFollowMetaRefreshThatRefreshesAfterMoreThanOneSecond(self):
page = self.webserver.where_is('navigation/res/60s-meta-redirect.html')
self.driver.get(page)
url = self.driver.get_current_url()
url = self.driver.current_url
self.assertEquals(page, url)

2
tests/wpt/web-platform-tests/webdriver/navigation/invalid_cert_test.py
View file

@ -21,7 +21,7 @@ class InvalidCertTest(base_test.WebDriverBaseTest):
'navigation/res/empty.html').replace('http:', 'https:', 1)
self.driver.get(expected)
self.assertEquals(expected, self.driver.get_current_url())
self.assertEquals(expected, self.driver.current_url)
if __name__ == '__main__':

27
tests/wpt/web-platform-tests/webdriver/navigation/refresh_page.py Normal file
View file

@ -0,0 +1,27 @@
import os
import sys
import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
class RefreshPageTest(base_test.WebDriverBaseTest):
# Get a static page that must be the same upon refresh
def test_refreshPage(self):
self.driver.get(self.webserver.where_is('navigation/res/refreshPageStatic.html'))
body = self.driver.find_element_by_css_selector("body").text
self.driver.execute_script("document.getElementById('body').innerHTML=''")
self.driver.refresh()
newbody = self.driver.find_element_by_css_selector("body").text
self.assertEqual(body, newbody)
self.driver.get(self.webserver.where_is('navigation/res/refreshPageDynamic.html'))
body = self.driver.find_element_by_css_selector("body").text
self.driver.refresh()
newbody = self.driver.find_element_by_css_selector("body").text
self.assertNotEqual(body, newbody)
if __name__ == '__main__':
unittest.main()

42
tests/wpt/web-platform-tests/webdriver/runtests_p0.py Normal file
View file

@ -0,0 +1,42 @@
import unittest
from unittest import TestLoader, TextTestRunner, TestSuite
from cookie import cookie_test
from navigation import forward
from navigation import forwardToNothing
from navigation import get_from_http_test
from navigation import refresh_page
from element_location import element_location_test
from element_state import visibility_test
from element_state import method_test
from element_state import properties
from javascript import execute_script_test
from user_input import clear_test
from windows import window_manipulation
from windows import tabbing
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromModule(cookie_test),
loader.loadTestsFromModule(forward),
loader.loadTestsFromModule(forwardToNothing),
loader.loadTestsFromModule(element_location_test),
loader.loadTestsFromModule(visibility_test),
loader.loadTestsFromModule(execute_script_test),
loader.loadTestsFromModule(clear_test),
loader.loadTestsFromModule(method_test),
loader.loadTestsFromModule(properties),
loader.loadTestsFromModule(refresh_page),
loader.loadTestsFromModule(get_from_http_test),
loader.loadTestsFromModule(window_manipulation),
loader.loadTestsFromModule(tabbing)
))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
unittest.main()

1
tests/wpt/web-platform-tests/webdriver/screenshot/__init__.py Normal file
View file

@ -0,0 +1 @@
__author__ = 'b-redeg'

5
tests/wpt/web-platform-tests/webdriver/screenshot/res/screenshot.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<meta charset="utf-8" />
<title>"img" element with not fully qualified url</title>
<img src="//web-platform.test:8000/images/blue.png">&nbsp;</a>

15
tests/wpt/web-platform-tests/webdriver/screenshot/take_screenshot.py Normal file
View file

@ -0,0 +1,15 @@
import os
import sys
import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
class ScreenShotTest(base_test.WebDriverBaseTest):
# Get a static page that must be the same upon refresh
def test_screenShot(self):
self.driver.get(self.webserver.where_is('screenshot/res/screen.html'))
if __name__ == '__main__':
unittest.main()

36
tests/wpt/web-platform-tests/webdriver/timeouts/implicit_waits_tests.py
View file

@ -4,7 +4,7 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions
from selenium.common import exceptions
class ImplicitWaitsTests(base_test.WebDriverBaseTest):
@ -12,15 +12,15 @@ class ImplicitWaitsTests(base_test.WebDriverBaseTest):
self.driver.get(self.webserver.where_is('timeouts/res/implicit_waits_tests.html'))
def test_find_element_by_id(self):
add = self.driver.find_element_by_css("#adder")
self.driver.set_implicit_timeout(3)
add = self.driver.find_element_by_css_selector("#adder")
self.driver.implicitly_wait(3)
add.click()
self.driver.find_element_by_css("#box0") # All is well if this doesn't throw.
self.driver.find_element_by_css_selector("#box0") # All is well if this doesn't throw.
def test_should_still_fail_to_find_an_element_when_implicit_waits_are_enabled(self):
self.driver.set_implicit_timeout(0.5)
self.driver.implicitly_wait(0.5)
try:
self.driver.find_element_by_css("#box0")
self.driver.find_element_by_css_selector("#box0")
self.fail("Expected NoSuchElementException to have been thrown")
except exceptions.NoSuchElementException as e:
pass
@ -28,10 +28,10 @@ class ImplicitWaitsTests(base_test.WebDriverBaseTest):
self.fail("Expected NoSuchElementException but got " + str(e))
def test_should_return_after_first_attempt_to_find_one_after_disabling_implicit_waits(self):
self.driver.set_implicit_timeout(3)
self.driver.set_implicit_timeout(0)
self.driver.implicitly_wait(3)
self.driver.implicitly_wait(0)
try:
self.driver.find_element_by_css("#box0")
self.driver.find_element_by_css_selector("#box0")
self.fail("Expected NoSuchElementException to have been thrown")
except exceptions.NoSuchElementException as e:
pass
@ -39,24 +39,24 @@ class ImplicitWaitsTests(base_test.WebDriverBaseTest):
self.fail("Expected NoSuchElementException but got " + str(e))
def test_should_implicitly_wait_until_at_least_one_element_is_found_when_searching_for_many(self):
add = self.driver.find_element_by_css("#adder")
self.driver.set_implicit_timeout(2)
add = self.driver.find_element_by_css_selector("#adder")
self.driver.implicitly_wait(2)
add.click()
add.click()
elements = self.driver.find_elements_by_css(".redbox")
elements = self.driver.find_elements_by_css_selector(".redbox")
self.assertTrue(len(elements) >= 1)
def test_should_still_fail_to_find_an_element_by_class_when_implicit_waits_are_enabled(self):
self.driver.set_implicit_timeout(0.5)
elements = self.driver.find_elements_by_css(".redbox")
self.driver.implicitly_wait(0.5)
elements = self.driver.find_elements_by_css_selector(".redbox")
self.assertEqual(0, len(elements))
def test_should_return_after_first_attempt_to_find_many_after_disabling_implicit_waits(self):
add = self.driver.find_element_by_css("#adder")
self.driver.set_implicit_timeout(1.1)
self.driver.set_implicit_timeout(0)
add = self.driver.find_element_by_css_selector("#adder")
self.driver.implicitly_wait(1.1)
self.driver.implicitly_wait(0)
add.click()
elements = self.driver.find_elements_by_css(".redbox")
elements = self.driver.find_elements_by_css_selector(".redbox")
self.assertEqual(0, len(elements))

2
tests/wpt/web-platform-tests/webdriver/timeouts/page_load_timeouts_tests.py
View file

@ -4,7 +4,7 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions
from selenium.common import exceptions
class PageLoadTimeoutTest(base_test.WebDriverBaseTest):

16
tests/wpt/web-platform-tests/webdriver/user_input/clear_test.py
View file

@ -6,45 +6,45 @@ import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from webdriver import exceptions
from selenium.common import exceptions
class ElementClearTest(base_test.WebDriverBaseTest):
def test_writable_text_input_element_should_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_writable_input_page.html"))
e = self.driver.find_element_by_css("#writableTextInput")
e = self.driver.find_element_by_css_selector("#writableTextInput")
e.clear()
self.assertEquals("", e.get_attribute("value"))
def test_disabled_text_input_element_should_not_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_disabled_input_page.html"))
e = self.driver.find_element_by_css("#disabledTextInput")
e = self.driver.find_element_by_css_selector("#disabledTextInput")
self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_read_only_text_input_element_should_not_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_readonly_input_page.html"))
e = self.driver.find_element_by_css("#readOnlyTextInput")
e = self.driver.find_element_by_css_selector("#readOnlyTextInput")
self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_writable_text_area_element_should_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_writable_textarea_page.html"))
e = self.driver.find_element_by_css("#writableTextArea")
e = self.driver.find_element_by_css_selector("#writableTextArea")
e.clear()
self.assertEquals("", e.get_attribute("value"))
def test_disabled_text_area_element_should_not_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_disabled_textarea_page.html"))
e = self.driver.find_element_by_css("#disabledTextArea")
e = self.driver.find_element_by_css_selector("#disabledTextArea")
self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_read_only_text_input_element_should_not_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_readonly_textarea_page.html"))
e = self.driver.find_element_by_css("#readOnlyTextArea")
e = self.driver.find_element_by_css_selector("#readOnlyTextArea")
self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_content_editable_area_should_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_contenteditable_page.html"))
e = self.driver.find_element_by_css("#contentEditableElement")
e = self.driver.find_element_by_css_selector("#contentEditableElement")
e.clear()
self.assertEquals("", e.text)

4
tests/wpt/web-platform-tests/webdriver/webdriver.cfg
View file

@ -21,6 +21,10 @@ mode: compatibility
capabilities: {"browserName": "ie"}
mode: compatibility
[edge]
capabilities: {"browserName": "edge"}
mode: compatibility
[ios-driver]
capabilities: {"browserName": "iphone"}
mode: compatibility

1
tests/wpt/web-platform-tests/webdriver/windows/__init__.py Normal file
View file

@ -0,0 +1 @@
__author__ = 'b-redeg'

5
tests/wpt/web-platform-tests/webdriver/windows/res/win1.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<meta charset="utf-8" />
<title>window one</title>
<div onclick="window.open('win2.html')">win2</div>

5
tests/wpt/web-platform-tests/webdriver/windows/res/win2.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<meta charset="utf-8" />
<title>window two</title>
<img src="//web-platform.test:8000/images/blue.png">&nbsp;</a>

5
tests/wpt/web-platform-tests/webdriver/windows/res/win3.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<meta charset="utf-8" />
<title>window three</title>
<img src="//web-platform.test:8000/images/blue.png">&nbsp;</a>

5
tests/wpt/web-platform-tests/webdriver/windows/res/win4.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<meta charset="utf-8" />
<title>window four</title>
<img src="//web-platform.test:8000/images/blue.png">&nbsp;</a>

5
tests/wpt/web-platform-tests/webdriver/windows/res/win5.html Normal file
View file

@ -0,0 +1,5 @@
<!DOCTYPE html>
<meta charset="utf-8" />
<title>window five</title>
<img src="//web-platform.test:8000/images/blue.png">&nbsp;</a>

30
tests/wpt/web-platform-tests/webdriver/windows/tabbing.py Normal file
View file

@ -0,0 +1,30 @@
# -*- mode: python; fill-column: 100; comment-column: 100; -*-
import os
import sys
import unittest
import time
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from selenium.common import exceptions
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains
class tabbingTest(base_test.WebDriverBaseTest):
def test_open_close_tab(self):
self.driver.get(self.webserver.where_is("windows/res/win1.html"))
self.driver.find_element_by_tag_name("div").click()
h = self.driver.window_handles
self.assertEquals(2, len(h))
self.driver.switch_to.window(h[1])
try:
self.driver.switch_to.window("does not exist")
self.fail("NoSuchWindowException expected")
except exceptions.NoSuchWindowException:
pass
self.driver.close()
if __name__ == "__main__":
unittest.main()

43
tests/wpt/web-platform-tests/webdriver/windows/window_manipulation.py Normal file
View file

@ -0,0 +1,43 @@
# -*- mode: python; fill-column: 100; comment-column: 100; -*-
import os
import sys
import unittest
sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test
from selenium.common import exceptions
class WindowingTest(base_test.WebDriverBaseTest):
def test_maximize(self):
#self.driver.get(self.webserver.where_is("windows/res/win1.html"))
self.driver.maximize_window()
def test_window_size_manipulation(self):
#self.driver.get(self.webserver.where_is("windows/res/win1.html"))
self.driver.set_window_size(400, 400)
window_size = self.driver.get_window_size()
self.assertTrue("width" in window_size)
self.assertTrue("height" in window_size)
self.assertEquals({"width": 400, "height":400}, window_size)
"""
todo: make that work
see: https://w3c.github.io/webdriver/webdriver-spec.html#setwindowsize
result = self.driver.set_window_size(100, 100)
self.assertTrue("status" in result)
self.assertEquals(result["status"], 500)
"""
def test_window_position_manipulation(self):
#self.driver.get(self.webserver.where_is("windows/res/win1.html"))
self.driver.set_window_position(400, 400)
window_position = self.driver.get_window_position()
self.assertTrue("x" in window_position)
self.assertTrue("y" in window_position)
self.assertEquals({"x": 400, "y": 400}, window_position)
if __name__ == "__main__":
unittest.main()