Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 13:40:08 +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", "path": "IndexedDB/idbobjectstore_openCursor_invalid.htm",
"url": "/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", "path": "IndexedDB/idbobjectstore_put.htm",
"url": "/IndexedDB/idbobjectstore_put.htm" "url": "/IndexedDB/idbobjectstore_put.htm"
@ -29747,6 +29751,9 @@
{ {
"path": "webdriver/element_state/method_test.py" "path": "webdriver/element_state/method_test.py"
}, },
{
"path": "webdriver/element_state/properties.py"
},
{ {
"path": "webdriver/element_state/visibility_test.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/navigation/refresh_page.py"
},
{
"path": "webdriver/screenshot/take_screenshot.py"
},
{ {
"path": "webdriver/timeouts/implicit_waits_tests.py" "path": "webdriver/timeouts/implicit_waits_tests.py"
}, },
@ -29785,6 +29798,12 @@
}, },
{ {
"path": "webdriver/user_input/clear_test.py" "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": "/", "url_base": "/",
"version": 2 "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] [The SecurityError must be thrown if the container's document does not have the same effective script origin]
expected: FAIL 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 type: testharness
[ask for reset on node remove, non multiple.] [ask for reset on node remove, non multiple.]
expected: FAIL 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 node_modules
scratch scratch
testharness_runner.html 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 databaseName = "database";
var databaseVersion = 1; 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 /* Delete created databases
* *
* Go through each finished test, see if it has an associated database. Close * 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 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 cross-browser testsuite for the Web-platform stack. However, for mainly
way that allows them to be run in all browsers gives browser projects 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 confidence that they are shipping software that is compatible with other
implementations, and that later implementations will be compatible with implementations, and that later implementations will be compatible with
their implementations. This in turn gives Web authors/developers 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> <title>scripthash-unicode-normalization</title>
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.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> </script>
<!-- enforcing policy: <!-- 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"> <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> </head>
<body> <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> <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. 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> </p>
<div id="log"></div> <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> </body>
</html> </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 Cache-Control: post-check=0, pre-check=0, false
Pragma: no-cache Pragma: no-cache
Set-Cookie: scripthash-unicode-normalization={{$id:uuid()}}; Path=/content-security-policy/blink-contrib-2 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> <script>
var t1 = async_test("The window's frameElement attribute must return its container element if it is a nested browsing context"); 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() { function on_load() {
t1.step(function () { t1.step(function () {
@ -17,9 +18,9 @@ function on_load() {
"The frameElement attribute should be the object element."); "The frameElement attribute should be the object element.");
assert_equals(window["win3"].frameElement, document.getElementById("emb"), assert_equals(window["win3"].frameElement, document.getElementById("emb"),
"The frameElement attribute should be the embed element."); "The frameElement attribute should be the embed element.");
assert_equals(document.getElementById("fr3").contentWindow[0].frameElement, assert_equals(document.getElementById("fr4").contentWindow[0].frameElement,
document.getElementById("fr3").contentDocument.getElementById("f1"), document.getElementById("fr4").contentDocument.getElementById("f1"),
"The frameElement attribute should be the frame element in 'test.html'."); "The frameElement attribute should be the frame element in 'test.html'.");
}); });
t1.done(); t1.done();
@ -28,23 +29,39 @@ function on_load() {
"The SecurityError exception should be thrown."); "The SecurityError exception should be thrown.");
}); });
t2.done(); 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> </script>
<body onload="on_load()"> <body onload="on_load()">
<div id="log"></div> <div id="log"></div>
<iframe id="fr1"></iframe> <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> <iframe id="fr3" src="" style="display:none"></iframe>
<object id="obj" name="win2" type="text/html" data="about:blank"></object> <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" /> <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> <script>
setup(function () { setup(function () {
var src = "http://{{domains[www1]}}:{{ports[http][0]}}"; var src_base = "http://{{domains[www1]}}:{{ports[http][0]}}";
src += document.location.pathname.substring(0, document.location.pathname.lastIndexOf("/") + 1); src_base += document.location.pathname.substring(0, document.location.pathname.lastIndexOf("/") + 1);
src += "test.html"; document.getElementById("fr2").src = src_base + "test.html";
document.getElementById("fr2").src = src; document.getElementById("fr5").src = src_base + "testcase3.html";
}); });
test(function () { 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', NO_MODIFICATION_ALLOWED_ERR: 'NoModificationAllowedError',
NOT_FOUND_ERR: 'NotFoundError', NOT_FOUND_ERR: 'NotFoundError',
NOT_SUPPORTED_ERR: 'NotSupportedError', NOT_SUPPORTED_ERR: 'NotSupportedError',
INUSE_ATTRIBUTE_ERR: 'InUseAttributeError',
INVALID_STATE_ERR: 'InvalidStateError', INVALID_STATE_ERR: 'InvalidStateError',
SYNTAX_ERR: 'SyntaxError', SYNTAX_ERR: 'SyntaxError',
INVALID_MODIFICATION_ERR: 'InvalidModificationError', INVALID_MODIFICATION_ERR: 'InvalidModificationError',
@ -1202,6 +1203,7 @@ policies and contribution forms [3].
NoModificationAllowedError: 7, NoModificationAllowedError: 7,
NotFoundError: 8, NotFoundError: 8,
NotSupportedError: 9, NotSupportedError: 9,
InUseAttributeError: 10,
InvalidStateError: 11, InvalidStateError: 11,
SyntaxError: 12, SyntaxError: 12,
InvalidModificationError: 13, 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", "webdriver"))
sys.path.insert(1, os.path.join(repo_root, "tools", "wptserve")) sys.path.insert(1, os.path.join(repo_root, "tools", "wptserve"))
from wptserve import server from wptserve import server
from webdriver.driver import WebDriver from selenium import webdriver
class WebDriverBaseTest(unittest.TestCase): class WebDriverBaseTest(unittest.TestCase):
@ -33,9 +33,10 @@ def create_driver():
config = ConfigParser.ConfigParser() config = ConfigParser.ConfigParser()
config.read('webdriver.cfg') config.read('webdriver.cfg')
section = os.environ.get("WD_BROWSER", 'firefox') section = os.environ.get("WD_BROWSER", 'firefox')
url = 'http://127.0.0.1:4444/wd/hub'
if config.has_option(section, 'url'): if config.has_option(section, 'url'):
url = config.get(section, "url") url = config.get(section, "url")
else:
url = 'http://127.0.0.1:4444/wd/hub'
capabilities = None capabilities = None
if config.has_option(section, 'capabilities'): if config.has_option(section, 'capabilities'):
try: try:
@ -45,5 +46,15 @@ def create_driver():
mode = 'compatibility' mode = 'compatibility'
if config.has_option(section, 'mode'): if config.has_option(section, 'mode'):
mode = config.get(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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions from selenium.common import exceptions
class CookieTest(base_test.WebDriverBaseTest): 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")) self.driver.get(self.webserver.where_is("cookie/res/cookie_container.html"))
def test_can_create_a_well_formed_cookie( self ): def test_can_create_a_well_formed_cookie( self ):
name = 'foo' self.driver.add_cookie({'name': 'foo', 'value': 'bar'})
value = 'bar'
self.driver.add_cookie({ 'name': name, 'value': value })
def test_cookies_should_allow_secure_to_be_set( self ): def test_cookies_should_allow_secure_to_be_set( self ):
name = 'foo' name = 'foo'
value = 'bar' self.driver.add_cookie({'name': name,
secure = True 'value': 'bar',
'path': '/',
self.driver.add_cookie({ 'name': name, 'secure': (True)})
'value': value,
'path': '/',
'secure': secure})
self.assertTrue(self.driver.get_cookie(name)[0]['secure']) self.assertTrue(self.driver.get_cookie(name)[0]['secure'])
def test_secure_defaults_to_false( self ): 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): def test_should_throw_an_exception_when_semicolon_exists_in_the_cookie_attribute(self):
invalid_name = 'foo;bar' invalid_name = 'foo;bar'
value = 'foobar'
try: 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.' ) self.fail( 'should have thrown exceptions.' )
except exceptions.UnableToSetCookieException: except exceptions.UnableToSetCookieException:
@ -51,10 +43,8 @@ class CookieTest(base_test.WebDriverBaseTest):
pass pass
def test_should_throw_an_exception_the_name_is_null(self): def test_should_throw_an_exception_the_name_is_null(self):
val = 'foobar'
try: try:
self.driver.add_cookie({ 'name': None, 'value': val }) self.driver.add_cookie({'name': None, 'value': 'foobar'})
self.fail( 'should have thrown exceptions.' ) self.fail( 'should have thrown exceptions.' )
except exceptions.UnableToSetCookieException: 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
class ElementLocationTest(base_test.WebDriverBaseTest): class ElementLocationTest(base_test.WebDriverBaseTest):
def test_find_element_by_name(self): def test_find_element_by_name(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html")) 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) self.assertEquals("name", e.text)
def test_find_element_by_css_selector(self): def test_find_element_by_css_selector(self):
self.driver.get(self.webserver.where_is("element_location/res/elements.html")) 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) self.assertEquals("id", e.text)
def test_find_element_by_link_text(self): 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']") e = self.driver.find_element_by_xpath("//*[@id='id']")
self.assertEquals("id", e.text) 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__": if __name__ == "__main__":
unittest.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): class GetElementAttributeTest(base_test.WebDriverBaseTest):
def test_get_element_attribute(self): def test_get_element_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-id-attribute.html")) 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")) self.assertEqual("myId", el.get_attribute("id"))
def test_style_attribute(self): def test_style_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-style-attribute.html")) 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 = """ expected_style = """
font-family: \"Gill Sans Extrabold\",Helvetica,sans-serif; font-family: \"Gill Sans Extrabold\",Helvetica,sans-serif;
line-height: 1.2; font-weight: bold; line-height: 1.2; font-weight: bold;
@ -23,47 +23,47 @@ class GetElementAttributeTest(base_test.WebDriverBaseTest):
def test_color_serialization_of_style_attribute(self): def test_color_serialization_of_style_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-color-style-attribute.html")) 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")) self.assertEqual("color: rgba(255, 0, 0, 1.0);", el.get_attribute("style"))
def test_true_if_boolean_attribute_present(self): def test_true_if_boolean_attribute_present(self):
self.driver.get(self.webserver.where_is("element_state/res/input-with-checked-attribute.html")) 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")) self.assertEqual("true", el.get_attribute("checked"))
def test_none_if_boolean_attribute_absent(self): def test_none_if_boolean_attribute_absent(self):
self.driver.get(self.webserver.where_is("element_state/res/input-without-checked-attribute.html")) 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")) self.assertIsNone(el.get_attribute("checked"))
def test_option_with_attribute_value(self): def test_option_with_attribute_value(self):
self.driver.get(self.webserver.where_is("element_state/res/option-with-value-attribute.html")) 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")) self.assertEqual("value1", el.get_attribute("value"))
def test_option_without_value_attribute(self): def test_option_without_value_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/option-without-value-attribute.html")) 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")) self.assertEqual("Value 1", el.get_attribute("value"))
def test_a_href_attribute(self): def test_a_href_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/a-with-href-attribute.html")) 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")) self.assertEqual("http://web-platform.test:8000/path#fragment", el.get_attribute("href"))
def test_img_src_attribute(self): def test_img_src_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/img-with-src-attribute.html")) 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")) self.assertEqual("http://web-platform.test:8000/images/blue.png", el.get_attribute("src"))
def test_custom_attribute(self): def test_custom_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/element-with-custom-attribute.html")) 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")) self.assertEqual("attribute value", el.get_attribute("webdriver-custom-attribute"))
def test_attribute_not_present(self): def test_attribute_not_present(self):
self.driver.get(self.webserver.where_is("element_state/res/element-without-attribute.html")) 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")) 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions from selenium.common import exceptions
class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest): class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
def test_0x0_pixel_element_is_not_visible(self): def test_0x0_pixel_element_is_not_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/0x0-pixels.html")) 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()) self.assertFalse(el.is_displayed())
def test_0x0_pixel_text_node_is_visible(self): def test_0x0_pixel_text_node_is_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/0x0-pixels-text-node.html")) 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()) self.assertTrue(el.is_displayed())
def test_1x1_pixel_element(self): def test_1x1_pixel_element(self):
self.driver.get(self.webserver.where_is("element_state/res/1x1-pixels.html")) 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()) self.assertTrue(el.is_displayed())
def test_zero_sized_element_is_shown_if_decendant_has_size(self): 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")) 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") parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css("#child") child = self.driver.find_element_by_css_selector("#child")
self.assertTrue(parent.is_displayed()) self.assertTrue(parent.is_displayed())
self.assertTrue(child.is_displayed()) self.assertTrue(child.is_displayed())
def test_input_type_hidden_is_never_visible(self): def test_input_type_hidden_is_never_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/input-type-hidden.html")) 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()) self.assertFalse(input.is_displayed())
def test_input_morphs_into_hidden(self): def test_input_morphs_into_hidden(self):
self.driver.get(self.webserver.where_is("element_state/res/input-morphs-into-hidden.html")) 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()) self.assertFalse(input.is_displayed())
def test_parent_node_visible_when_all_children_are_absolutely_positioned_and_overflow_is_hidden(self): 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")) 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) 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() assert parent.is_displayed()
def test_element_hidden_by_overflow_x_is_not_visible(self): def test_element_hidden_by_overflow_x_is_not_visible(self):
@ -66,8 +66,8 @@ class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
for page in pages: for page in pages:
self.driver.get(self.webserver.where_is(page)) self.driver.get(self.webserver.where_is(page))
right = self.driver.find_element_by_css("#right") right = self.driver.find_element_by_css_selector("#right")
bottom_right = self.driver.find_element_by_css("#bottom-right") bottom_right = self.driver.find_element_by_css_selector("#bottom-right")
self.assertFalse(right.is_displayed()) self.assertFalse(right.is_displayed())
self.assertFalse(bottom_right.is_displayed()) self.assertFalse(bottom_right.is_displayed())
@ -81,8 +81,8 @@ class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
for page in pages: for page in pages:
self.driver.get(self.webserver.where_is(page)) self.driver.get(self.webserver.where_is(page))
bottom = self.driver.find_element_by_css("#bottom") bottom = self.driver.find_element_by_css_selector("#bottom")
bottom_right = self.driver.find_element_by_css("#bottom-right") bottom_right = self.driver.find_element_by_css_selector("#bottom-right")
self.assertFalse(bottom.is_displayed()) self.assertFalse(bottom.is_displayed())
self.assertFalse(bottom_right.is_displayed()) self.assertFalse(bottom_right.is_displayed())
@ -104,78 +104,78 @@ class NaturalNonVisibleElementsTest(base_test.WebDriverBaseTest):
def test_element_outside_viewport(self): def test_element_outside_viewport(self):
self.driver.get(self.webserver.where_is("element_state/res/element-outside-viewport.html")) 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()) self.assertFalse(hidden.is_displayed())
def test_element_dynamically_moved_outside_viewport(self): def test_element_dynamically_moved_outside_viewport(self):
self.driver.get(self.webserver.where_is("element_state/res/element-dynamically-moved-outside-viewport.html")) 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()) self.assertFalse(hidden.is_displayed())
def test_element_hidden_by_other_element(self): def test_element_hidden_by_other_element(self):
self.driver.get(self.webserver.where_is("element_state/res/element-hidden-by-other-element.html")) self.driver.get(self.webserver.where_is("element_state/res/element-hidden-by-other-element.html"))
overlay = self.driver.find_element_by_css("#overlay") overlay = self.driver.find_element_by_css_selector("#overlay")
hidden = self.driver.find_element_by_css("#hidden") hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertTrue(overlay.is_displayed()) self.assertTrue(overlay.is_displayed())
self.assertFalse(hidden.is_displayed()) self.assertFalse(hidden.is_displayed())
def test_element_partially_hidden_by_other_element(self): 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")) 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()) self.assertTrue(partial.is_displayed())
def test_element_hidden_by_z_index(self): def test_element_hidden_by_z_index(self):
self.driver.get(self.webserver.where_is("element_state/res/element-hidden-by-z-index.html")) self.driver.get(self.webserver.where_is("element_state/res/element-hidden-by-z-index.html"))
overlay = self.driver.find_element_by_css("#overlay") overlay = self.driver.find_element_by_css_selector("#overlay")
hidden = self.driver.find_element_by_css("#hidden") hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertTrue(overlay.is_displayed()) self.assertTrue(overlay.is_displayed())
self.assertFalse(hidden.is_displayed()) self.assertFalse(hidden.is_displayed())
def test_element_moved_outside_viewport_by_transform(self): 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")) 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()) self.assertFalse(el.is_displayed())
def test_element_moved_behind_other_element_by_transform(self): 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")) 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") overlay = self.driver.find_element_by_css_selector("#overlay")
hidden = self.driver.find_element_by_css("#hidden") hidden = self.driver.find_element_by_css_selector("#hidden")
self.assertTrue(overlay.is_displayed()) self.assertTrue(overlay.is_displayed())
self.assertFalse(hidden.is_displayed()) self.assertFalse(hidden.is_displayed())
def test_text_with_same_color_as_background(self): 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")) 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()) self.assertFalse(p.is_displayed())
def test_text_with_same_color_as_parent_background(self): 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")) 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()) self.assertFalse(p.is_displayed())
def test_text_with_matching_color_and_background(self): 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")) 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()) self.assertTrue(p.is_displayed())
def test_element_with_same_color_as_background(self): 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")) 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()) self.assertFalse(el.is_displayed())
def test_element_with_same_color_as_parent_background(self): 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")) 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()) self.assertFalse(hidden.is_displayed())
class BodyElementIsAlwaysDisplayedTest(base_test.WebDriverBaseTest): class BodyElementIsAlwaysDisplayedTest(base_test.WebDriverBaseTest):
def assert_body_is_displayed_on(self, page): def assert_body_is_displayed_on(self, page):
self.driver.get(self.webserver.where_is(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() assert body.is_displayed()
def test_implicit(self): def test_implicit(self):
@ -194,86 +194,86 @@ class BodyElementIsAlwaysDisplayedTest(base_test.WebDriverBaseTest):
class DisplayTest(base_test.WebDriverBaseTest): class DisplayTest(base_test.WebDriverBaseTest):
def test_display_block(self): def test_display_block(self):
self.driver.get(self.webserver.where_is("element_state/res/display-block.html")) 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()) self.assertTrue(el.is_displayed())
def test_display_none(self): def test_display_none(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none.html")) 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()) self.assertFalse(el.is_displayed())
def test_display_none_hides_child_node(self): def test_display_none_hides_child_node(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-child.html")) self.driver.get(self.webserver.where_is("element_state/res/display-none-child.html"))
parent = self.driver.find_element_by_css("#parent") parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css("#child") child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed()) self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed()) self.assertFalse(child.is_displayed())
def test_display_none_hides_child_node_link(self): def test_display_none_hides_child_node_link(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-child-link.html")) 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()) self.assertFalse(child.is_displayed())
def test_display_none_hides_child_node_paragraph(self): def test_display_none_hides_child_node_paragraph(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-child-paragraph.html")) 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()) self.assertFalse(child.is_displayed())
def test_display_none_on_parent_takes_presedence(self): def test_display_none_on_parent_takes_presedence(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-parent-presedence.html")) 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()) self.assertFalse(child.is_displayed())
def test_display_none_on_parent_takes_presedence_over_visibility_visible(self): 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")) 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()) self.assertFalse(child.is_displayed())
def test_display_none_hidden_dynamically(self): def test_display_none_hidden_dynamically(self):
self.driver.get(self.webserver.where_is("element_state/res/display-none-dynamic.html")) 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()) self.assertFalse(hidden.is_displayed())
class VisibilityTest(base_test.WebDriverBaseTest): class VisibilityTest(base_test.WebDriverBaseTest):
def test_element_state_hidden(self): def test_element_state_hidden(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-hidden.html")) 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()) self.assertFalse(el.is_displayed())
def test_element_state_visible(self): def test_element_state_visible(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-visible.html")) 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()) self.assertTrue(el.is_displayed())
def test_visibility_hidden_hides_child_node(self): def test_visibility_hidden_hides_child_node(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child.html")) self.driver.get(self.webserver.where_is("element_state/res/visibility-child.html"))
parent = self.driver.find_element_by_css("#parent") parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css("#child") child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed()) self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed()) self.assertFalse(child.is_displayed())
def test_visibility_hidden_hides_child_node_link(self): def test_visibility_hidden_hides_child_node_link(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child-link.html")) self.driver.get(self.webserver.where_is("element_state/res/visibility-child-link.html"))
parent = self.driver.find_element_by_css("#parent") parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css("#child") child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed()) self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed()) self.assertFalse(child.is_displayed())
def test_visibility_hidden_hides_child_node_paragraph(self): def test_visibility_hidden_hides_child_node_paragraph(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child-paragraph.html")) self.driver.get(self.webserver.where_is("element_state/res/visibility-child-paragraph.html"))
parent = self.driver.find_element_by_css("#parent") parent = self.driver.find_element_by_css_selector("#parent")
child = self.driver.find_element_by_css("#child") child = self.driver.find_element_by_css_selector("#child")
self.assertFalse(parent.is_displayed()) self.assertFalse(parent.is_displayed())
self.assertFalse(child.is_displayed()) self.assertFalse(child.is_displayed())
def test_visibility_hidden_on_child_takes_precedence(self): def test_visibility_hidden_on_child_takes_precedence(self):
self.driver.get(self.webserver.where_is("element_state/res/visibility-child-presedence.html")) 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()) self.assertTrue(child.is_displayed())
def test_visibility_hidden_on_parent_takes_precedence_over_display_block(self): 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): def test_should_show_element_not_visible_with_hidden_attribute(self):
self.driver.get(self.webserver.where_is("element_state/res/hidden.html")) 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()) self.assertFalse(singleHidden.is_displayed())
def test_should_show_element_not_visible_when_parent_element_has_hidden_attribute(self): 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")) 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()) self.assertFalse(child.is_displayed())
class VisibilityInteractionTest(base_test.WebDriverBaseTest): class VisibilityInteractionTest(base_test.WebDriverBaseTest):
def test_input_hidden_is_unclickable(self): def test_input_hidden_is_unclickable(self):
self.driver.get(self.webserver.where_is("element_state/res/input-type-hidden-unclickable.html")) 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): with self.assertRaises(exceptions.ElementNotVisibleException):
input.click() input.click()
def test_hidden_input_checkbox_is_untogglable(self): def test_hidden_input_checkbox_is_untogglable(self):
self.driver.get(self.webserver.where_is("element_state/res/hidden-input-type-checkbox-untogglable.html")) 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): with self.assertRaises(exceptions.ElementNotVisibleException):
checkbox.click() checkbox.click()
def test_typing_in_hidden_input_is_impossible(self): 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")) 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): with self.assertRaises(exceptions.ElementNotVisibleException):
textfield.send_keys("Koha is a popular Indian cheese") 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from selenium.webdriver.remote.webelement import WebElement
class ExecuteScriptTest(base_test.WebDriverBaseTest): 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions, wait from selenium.common import exceptions
from selenium.webdriver.support import wait
class AlertsQuitTest(base_test.WebDriverBaseTest): class AlertsQuitTest(base_test.WebDriverBaseTest):
def setUp(self): 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')) self.driver.get(self.webserver.where_is('modal/res/alerts.html'))
def test_can_quit_when_an_alert_is_present(self): 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()) alert = self.wait.until(lambda x: x.switch_to_alert())
self.driver.quit() self.driver.quit()
with self.assertRaises(Exception): 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions, wait from selenium.common import exceptions
from selenium.webdriver.support import wait
class AlertsTest(base_test.WebDriverBaseTest): class AlertsTest(base_test.WebDriverBaseTest):
def setUp(self): 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')) self.driver.get(self.webserver.where_is('modal/res/alerts.html'))
def tearDown(self): def tearDown(self):
try: try:
self.driver.switch_to_alert().dismiss() self.driver.switch_to_alert().dismiss()
except exceptions.NoSuchAlertException: except exceptions.NoAlertPresentException:
pass pass
# Alerts # Alerts
def test_should_allow_user_to_accept_an_alert(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() alert.accept()
self.driver.get_current_url() self.driver.current_url
def test_should_allow_user_to_accept_an_alert_with_no_text(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() alert.accept()
self.driver.get_current_url() self.driver.current_url
def test_should_allow_user_to_dismiss_an_alert(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss() alert.dismiss()
self.driver.get_current_url() self.driver.current_url
def test_should_allow_user_to_get_text_of_an_alert(self): 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()) alert = self.wait.until(lambda x: x.switch_to_alert())
value = alert.get_text() value = alert.text
alert.accept() alert.accept()
self.assertEquals('cheese', value) self.assertEquals('cheese', value)
def test_setting_the_value_of_an_alert_throws(self): 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()) alert = self.wait.until(lambda x: x.switch_to_alert())
with self.assertRaises(exceptions.ElementNotVisibleException): with self.assertRaises(exceptions.ElementNotVisibleException):
alert.send_keys('cheese') alert.send_keys('cheese')
alert.accept() alert.accept()
def test_alert_should_not_allow_additional_commands_if_dismissed(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() alert.accept()
with self.assertRaises(exceptions.NoSuchAlertException): with self.assertRaises(exceptions.NoAlertPresentException):
alert.get_text() alert.text
# Prompts # Prompts
def test_should_allow_user_to_accept_a_prompt(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() 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): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss() 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): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.send_keys('cheese') alert.send_keys('cheese')
alert.accept() 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): 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()) alert = self.wait.until(lambda x: x.switch_to_alert())
value = alert.get_text() value = alert.text
alert.accept() alert.accept()
self.assertEquals('Enter something', value) self.assertEquals('Enter something', value)
def test_prompt_should_not_allow_additional_commands_if_dismissed(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() alert.accept()
with self.assertRaises(exceptions.NoSuchAlertException): with self.assertRaises(exceptions.NoAlertPresentException):
alert.get_text() alert.text
def test_prompt_should_use_default_value_if_no_keys_sent(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() 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): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss() 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 # Confirmations
def test_should_allow_user_to_accept_a_confirm(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() 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): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.dismiss() 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): 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()) alert = self.wait.until(lambda x: x.switch_to_alert())
with self.assertRaises(exceptions.ElementNotVisibleException): with self.assertRaises(exceptions.ElementNotVisibleException):
alert.send_keys('cheese') alert.send_keys('cheese')
alert.accept() alert.accept()
def test_should_allow_user_to_get_text_of_a_confirm(self): 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()) alert = self.wait.until(lambda x: x.switch_to_alert())
value = alert.get_text() value = alert.text
alert.accept() alert.accept()
self.assertEquals('cheese', value) self.assertEquals('cheese', value)
def test_confirm_should_not_allow_additional_commands_if_dismissed(self): 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 = self.wait.until(lambda x: x.switch_to_alert())
alert.accept() alert.accept()
with self.assertRaises(exceptions.NoSuchAlertException): with self.assertRaises(exceptions.NoAlertPresentException):
alert.get_text() alert.text
"""
def test_switch_to_missing_alert_fails(self): def test_switch_to_missing_alert_fails(self):
with self.assertRaises(exceptions.NoSuchAlertException): with self.assertRaises(exceptions.NoAlertPresentException):
self.driver.switch_to_alert() self.driver.switch_to_alert()
"""
if __name__ == '__main__': if __name__ == '__main__':
unittest.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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions from selenium.common import exceptions
from wptserve import server from wptserve import server
from wptserve.router import any_method from wptserve.router import any_method
from wptserve.handlers import basic_auth_handler 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): def test_forward(self):
self.driver.get(self.webserver.where_is('navigation/res/forwardStart.html')) self.driver.get(self.webserver.where_is('navigation/res/forwardStart.html'))
self.driver.get(self.webserver.where_is('navigation/res/forwardNext.html')) self.driver.get(self.webserver.where_is('navigation/res/forwardNext.html'))
nextbody = self.driver.find_element_by_css("body").text nextbody = self.driver.find_element_by_css_selector("body").text
self.driver.go_back() self.driver.back()
currbody = self.driver.find_element_by_css("body").text currbody = self.driver.find_element_by_css_selector("body").text
self.assertNotEqual(nextbody, currbody) self.assertNotEqual(nextbody, currbody)
self.driver.go_forward() self.driver.forward()
currbody = self.driver.find_element_by_css("body").text currbody = self.driver.find_element_by_css_selector("body").text
self.assertEqual(nextbody, currbody) 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 # Get a static page that must be the same upon refresh
def test_forwardToNothing(self): def test_forwardToNothing(self):
self.driver.get(self.webserver.where_is('navigation/forwardStart.html')) self.driver.get(self.webserver.where_is('navigation/forwardStart.html'))
body = self.driver.find_element_by_css("body").text body = self.driver.find_element_by_css_selector("body").text
self.driver.go_forward() self.driver.forward()
currbody = self.driver.find_element_by_css("body").text currbody = self.driver.find_element_by_css_selector("body").text
self.assertEqual(body, currbody) 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): def testGetUrlWithNoRedirectionOverHttp(self):
page = self.webserver.where_is('navigation/res/empty.html') page = self.webserver.where_is('navigation/res/empty.html')
self.driver.get(page) self.driver.get(page)
url = self.driver.get_current_url() url = self.driver.current_url
self.assertEquals(page, url) self.assertEquals(page, url)
@ -18,7 +18,7 @@ class GetFromHttpTest(base_test.WebDriverBaseTest):
page = self.webserver.where_is('navigation/redirect') page = self.webserver.where_is('navigation/redirect')
self.driver.get(page) self.driver.get(page)
expected = self.webserver.where_is('navigation/res/empty.html') expected = self.webserver.where_is('navigation/res/empty.html')
url = self.driver.get_current_url() url = self.driver.current_url
self.assertEquals(expected, 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') page = self.webserver.where_is('navigation/res/instant-meta-redirect.html')
self.driver.get(page) self.driver.get(page)
expected = self.webserver.where_is('navigation/res/empty.html') expected = self.webserver.where_is('navigation/res/empty.html')
url = self.driver.get_current_url() url = self.driver.current_url
self.assertEquals(expected, 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') page = self.webserver.where_is('navigation/res/1s-meta-redirect.html')
self.driver.get(page) self.driver.get(page)
expected = self.webserver.where_is('navigation/res/empty.html') expected = self.webserver.where_is('navigation/res/empty.html')
url = self.driver.get_current_url() url = self.driver.current_url
self.assertEquals(expected, url) self.assertEquals(expected, url)
def testGetWillNotFollowMetaRefreshThatRefreshesAfterMoreThanOneSecond(self): def testGetWillNotFollowMetaRefreshThatRefreshesAfterMoreThanOneSecond(self):
page = self.webserver.where_is('navigation/res/60s-meta-redirect.html') page = self.webserver.where_is('navigation/res/60s-meta-redirect.html')
self.driver.get(page) self.driver.get(page)
url = self.driver.get_current_url() url = self.driver.current_url
self.assertEquals(page, 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) 'navigation/res/empty.html').replace('http:', 'https:', 1)
self.driver.get(expected) self.driver.get(expected)
self.assertEquals(expected, self.driver.get_current_url()) self.assertEquals(expected, self.driver.current_url)
if __name__ == '__main__': 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions from selenium.common import exceptions
class ImplicitWaitsTests(base_test.WebDriverBaseTest): 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')) self.driver.get(self.webserver.where_is('timeouts/res/implicit_waits_tests.html'))
def test_find_element_by_id(self): def test_find_element_by_id(self):
add = self.driver.find_element_by_css("#adder") add = self.driver.find_element_by_css_selector("#adder")
self.driver.set_implicit_timeout(3) self.driver.implicitly_wait(3)
add.click() 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): 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: try:
self.driver.find_element_by_css("#box0") self.driver.find_element_by_css_selector("#box0")
self.fail("Expected NoSuchElementException to have been thrown") self.fail("Expected NoSuchElementException to have been thrown")
except exceptions.NoSuchElementException as e: except exceptions.NoSuchElementException as e:
pass pass
@ -28,10 +28,10 @@ class ImplicitWaitsTests(base_test.WebDriverBaseTest):
self.fail("Expected NoSuchElementException but got " + str(e)) self.fail("Expected NoSuchElementException but got " + str(e))
def test_should_return_after_first_attempt_to_find_one_after_disabling_implicit_waits(self): def test_should_return_after_first_attempt_to_find_one_after_disabling_implicit_waits(self):
self.driver.set_implicit_timeout(3) self.driver.implicitly_wait(3)
self.driver.set_implicit_timeout(0) self.driver.implicitly_wait(0)
try: try:
self.driver.find_element_by_css("#box0") self.driver.find_element_by_css_selector("#box0")
self.fail("Expected NoSuchElementException to have been thrown") self.fail("Expected NoSuchElementException to have been thrown")
except exceptions.NoSuchElementException as e: except exceptions.NoSuchElementException as e:
pass pass
@ -39,24 +39,24 @@ class ImplicitWaitsTests(base_test.WebDriverBaseTest):
self.fail("Expected NoSuchElementException but got " + str(e)) 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): 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") add = self.driver.find_element_by_css_selector("#adder")
self.driver.set_implicit_timeout(2) self.driver.implicitly_wait(2)
add.click() add.click()
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) self.assertTrue(len(elements) >= 1)
def test_should_still_fail_to_find_an_element_by_class_when_implicit_waits_are_enabled(self): def test_should_still_fail_to_find_an_element_by_class_when_implicit_waits_are_enabled(self):
self.driver.set_implicit_timeout(0.5) self.driver.implicitly_wait(0.5)
elements = self.driver.find_elements_by_css(".redbox") elements = self.driver.find_elements_by_css_selector(".redbox")
self.assertEqual(0, len(elements)) self.assertEqual(0, len(elements))
def test_should_return_after_first_attempt_to_find_many_after_disabling_implicit_waits(self): def test_should_return_after_first_attempt_to_find_many_after_disabling_implicit_waits(self):
add = self.driver.find_element_by_css("#adder") add = self.driver.find_element_by_css_selector("#adder")
self.driver.set_implicit_timeout(1.1) self.driver.implicitly_wait(1.1)
self.driver.set_implicit_timeout(0) self.driver.implicitly_wait(0)
add.click() add.click()
elements = self.driver.find_elements_by_css(".redbox") elements = self.driver.find_elements_by_css_selector(".redbox")
self.assertEqual(0, len(elements)) 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions from selenium.common import exceptions
class PageLoadTimeoutTest(base_test.WebDriverBaseTest): 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__, "../.."))) sys.path.insert(1, os.path.abspath(os.path.join(__file__, "../..")))
import base_test import base_test
from webdriver import exceptions from selenium.common import exceptions
class ElementClearTest(base_test.WebDriverBaseTest): class ElementClearTest(base_test.WebDriverBaseTest):
def test_writable_text_input_element_should_clear(self): 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")) 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() e.clear()
self.assertEquals("", e.get_attribute("value")) self.assertEquals("", e.get_attribute("value"))
def test_disabled_text_input_element_should_not_clear(self): 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")) 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()) self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_read_only_text_input_element_should_not_clear(self): 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")) 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()) self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_writable_text_area_element_should_clear(self): 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")) 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() e.clear()
self.assertEquals("", e.get_attribute("value")) self.assertEquals("", e.get_attribute("value"))
def test_disabled_text_area_element_should_not_clear(self): 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")) 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()) self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_read_only_text_input_element_should_not_clear(self): 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")) 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()) self.assertRaises(exceptions.InvalidElementStateException, lambda: e.clear())
def test_content_editable_area_should_clear(self): def test_content_editable_area_should_clear(self):
self.driver.get(self.webserver.where_is("user_input/res/element_clear_contenteditable_page.html")) 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() e.clear()
self.assertEquals("", e.text) self.assertEquals("", e.text)

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

@ -21,6 +21,10 @@ mode: compatibility
capabilities: {"browserName": "ie"} capabilities: {"browserName": "ie"}
mode: compatibility mode: compatibility
[edge]
capabilities: {"browserName": "edge"}
mode: compatibility
[ios-driver] [ios-driver]
capabilities: {"browserName": "iphone"} capabilities: {"browserName": "iphone"}
mode: compatibility 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()