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

Update web-platform-tests to revision ea14651f262003177d0ba5819bd2806a1327b12a

Browse source
This commit is contained in:
WPT Sync Bot 2018-04-30 21:09:29 -04:00
parent 847115ba04
commit 816185f094
272 changed files with 5766 additions and 2855 deletions
Download patch file Download diff file Expand all files Collapse all files

10
tests/wpt/web-platform-tests/cookie-store/cookieStore_delete_basic.tentative.window.js Normal file
View file

@ -0,0 +1,10 @@
'use strict';
promise_test(async testCase => {
const p = cookieStore.delete('cookie-name');
assert_true(p instanceof Promise,
'cookieStore.delete() returns a promise');
const result = await p;
assert_equals(result, undefined,
'cookieStore.delete() promise resolves to undefined');
}, 'cookieStore.delete return type is Promise<void>');

8
tests/wpt/web-platform-tests/cookie-store/delete_cookies.tentative.html
View file

@ -1,8 +0,0 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>Async Cookies: delete cookies</title>
<meta name="help" href="https://github.com/WICG/cookie-store/">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="resources/cookie-test-helpers.js"></script>
<script src="resources/delete_cookies.js"></script>

8
tests/wpt/web-platform-tests/cookie-store/delete_cookies.tentative.https.html
View file

@ -1,8 +0,0 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>Async Cookies: delete cookies (HTTPS)</title>
<meta name="help" href="https://github.com/WICG/cookie-store/">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="resources/cookie-test-helpers.js"></script>
<script src="resources/delete_cookies.js"></script>

8
tests/wpt/web-platform-tests/cookie-store/get_set_get_all.tentative.html
View file

@ -1,8 +0,0 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>Async Cookies: get, set, getAll</title>
<meta name="help" href="https://github.com/WICG/cookie-store/">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="resources/cookie-test-helpers.js"></script>
<script src="resources/get_set_get_all.js"></script>

8
tests/wpt/web-platform-tests/cookie-store/get_set_get_all.tentative.https.html
View file

@ -1,8 +0,0 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>Async Cookies: get, set, getAll (HTTPS)</title>
<meta name="help" href="https://github.com/WICG/cookie-store/">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="resources/cookie-test-helpers.js"></script>
<script src="resources/get_set_get_all.js"></script>

47
tests/wpt/web-platform-tests/cookie-store/httponly_cookies.window.js Normal file
View file

@ -0,0 +1,47 @@
// META: script=resources/cookie-test-helpers.js
'use strict';
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp('HTTPONLY-cookie=value; path=/; httponly');
assert_equals(
await getCookieString(),
undefined,
'HttpOnly cookie we wrote using HTTP in cookie jar' +
' is invisible to script');
assert_equals(
await getCookieStringHttp(),
'HTTPONLY-cookie=value',
'HttpOnly cookie we wrote using HTTP in HTTP cookie jar');
await setCookieStringHttp('HTTPONLY-cookie=new-value; path=/; httponly');
assert_equals(
await getCookieString(),
undefined,
'HttpOnly cookie we overwrote using HTTP in cookie jar' +
' is invisible to script');
assert_equals(
await getCookieStringHttp(),
'HTTPONLY-cookie=new-value',
'HttpOnly cookie we overwrote using HTTP in HTTP cookie jar');
eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp(
'HTTPONLY-cookie=DELETED; path=/; max-age=0; httponly');
assert_equals(
await getCookieString(),
undefined,
'Empty cookie jar after HTTP cookie-clearing using max-age=0');
assert_equals(
await getCookieStringHttp(),
undefined,
'Empty HTTP cookie jar after HTTP cookie-clearing using max-age=0');
// HTTPONLY cookie changes should not have been observed; perform
// a dummy change to verify that nothing else was queued up.
await cookieStore.set('TEST', 'dummy');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'TEST', value: 'dummy'}]},
'HttpOnly cookie deletion was not observed');
}, 'HttpOnly cookies are not observed');

66
tests/wpt/web-platform-tests/cookie-store/resources/cookie-test-helpers.js
View file

@ -11,41 +11,6 @@ const kIsUnsecured = location.protocol !== 'https:';
const kCookieHelperCgi = 'resources/cookie_helper.py';
// Async wrapper for an async function or promise that is expected
// reject in an unsecured (non-https:) context and work in a secured
// (https:) context.
//
// Parameters:
//
// - testCase: (TestCase) test case context
// - code: (Error class or number) expected rejection type in unsecured context
// - promise: (thenable) test code
// - message: (optional; string) message to forward to promise_rejects in
// unsecured context
async function promise_rejects_when_unsecured(
testCase,
code,
promise,
message = 'Feature unavailable from unsecured contexts') {
if (kIsUnsecured)
await promise_rejects(testCase, code, promise, message);
else await promise;
};
// Converts a list of cookie records {name, value} to [name=]value; ... as
// seen in Cookie: and document.cookie.
//
// Parameters:
// - cookies: (array of {name, value}) records to convert
//
// Returns a string serializing the records, or undefined if no records were
// given.
function cookieString(cookies) {
return cookies.length ? cookies.map((
{name, value}) => (name ? (name + '=') : '') + value).join('; ') :
undefined;
}
// Approximate async equivalent to the document.cookie getter but with
// important differences: optional additional getAll arguments are
// forwarded, and an empty cookie jar returns undefined.
@ -56,7 +21,11 @@ function cookieString(cookies) {
// using parsed cookie jar contents and also allows expectations to be
// written more compactly.
async function getCookieString(...args) {
return cookieString(await cookieStore.getAll(...args));
const cookies = await cookieStore.getAll(...args);
return cookies.length
? cookies.map(({name, value}) =>
(name ? (name + '=') : '') + value).join('; ')
: undefined;
}
// Approximate async equivalent to the document.cookie getter but from
@ -240,31 +209,18 @@ async function verifyCookieChangeEvent(eventPromise, expected, description) {
async function cookie_test(func, description) {
// Wipe cookies used by tests before and after the test.
async function deleteTestCookies() {
await cookieStore.delete('');
await cookieStore.delete('TEST');
await cookieStore.delete('META-🍪');
await cookieStore.delete('DOCUMENT-🍪');
await cookieStore.delete('HTTP-🍪');
await setCookieStringHttp(
'HTTPONLY-🍪=DELETED; path=/; max-age=0; httponly');
if (!kIsUnsecured) {
await cookieStore.delete('__Host-COOKIENAME');
await cookieStore.delete('__Host-1🍪');
await cookieStore.delete('__Host-2🌟');
await cookieStore.delete('__Host-3🌱');
await cookieStore.delete('__Host-unordered1🍪');
await cookieStore.delete('__Host-unordered2🌟');
await cookieStore.delete('__Host-unordered3🌱');
}
async function deleteAllCookies() {
(await cookieStore.getAll()).forEach(({name, value}) => {
cookieStore.delete(name);
});
}
return promise_test(async t => {
await deleteTestCookies();
await deleteAllCookies();
try {
return await func(t);
} finally {
await deleteTestCookies();
await deleteAllCookies();
}
}, description);
}

44
tests/wpt/web-platform-tests/cookie-store/resources/delete_cookies.js
View file

@ -1,44 +0,0 @@
'use strict';
cookie_test(async testCase => {
// TODO: This test doesn't create cookies and doesn't assert
// the behavior of delete(). Improve or remove it.
await cookieStore.delete('');
await cookieStore.delete('TEST');
await cookieStore.delete('META-🍪');
await cookieStore.delete('DOCUMENT-🍪');
await cookieStore.delete('HTTP-🍪');
await setCookieStringHttp(
'HTTPONLY-🍪=DELETED; path=/; max-age=0; httponly');
await promise_rejects_when_unsecured(
testCase,
new TypeError(),
cookieStore.delete('__Host-COOKIENAME'));
await promise_rejects_when_unsecured(
testCase,
new TypeError(),
cookieStore.delete('__Host-1🍪'));
await promise_rejects_when_unsecured(
testCase,
new TypeError(),
cookieStore.delete('__Host-2🌟'));
await promise_rejects_when_unsecured(
testCase,
new TypeError(),
cookieStore.delete('__Host-3🌱'));
await promise_rejects_when_unsecured(
testCase,
new TypeError(),
cookieStore.delete('__Host-unordered1🍪'));
await promise_rejects_when_unsecured(
testCase,
new TypeError(),
cookieStore.delete('__Host-unordered2🌟'));
await promise_rejects_when_unsecured(
testCase,
new TypeError(),
cookieStore.delete('__Host-unordered3🌱'));
}, 'Test cookieStore.delete');

128
tests/wpt/web-platform-tests/cookie-store/resources/document_cookie.js
View file

@ -2,25 +2,43 @@
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await setCookieStringDocument('DOCUMENT-🍪=🔵; path=/');
await setCookieStringDocument('DOCUMENT-cookie=value; path=/');
assert_equals(
await getCookieString(),
'DOCUMENT-🍪=🔵',
'DOCUMENT-cookie=value',
'Cookie we wrote using document.cookie in cookie jar');
assert_equals(
await getCookieStringHttp(),
'DOCUMENT-🍪=🔵',
'DOCUMENT-cookie=value',
'Cookie we wrote using document.cookie in HTTP cookie jar');
assert_equals(
await getCookieStringDocument(),
'DOCUMENT-🍪=🔵',
'DOCUMENT-cookie=value',
'Cookie we wrote using document.cookie in document.cookie');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'DOCUMENT-🍪', value: '🔵'}]},
eventPromise, {changed: [{name: 'DOCUMENT-cookie', value: 'value'}]},
'Cookie we wrote using document.cookie is observed');
eventPromise = observeNextCookieChangeEvent();
await setCookieStringDocument('DOCUMENT-🍪=DELETED; path=/; max-age=0');
await setCookieStringDocument('DOCUMENT-cookie=new-value; path=/');
assert_equals(
await getCookieString(),
'DOCUMENT-cookie=new-value',
'Cookie we overwrote using document.cookie in cookie jar');
assert_equals(
await getCookieStringHttp(),
'DOCUMENT-cookie=new-value',
'Cookie we overwrote using document.cookie in HTTP cookie jar');
assert_equals(
await getCookieStringDocument(),
'DOCUMENT-cookie=new-value',
'Cookie we overwrote using document.cookie in document.cookie');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'DOCUMENT-cookie', value: 'new-value'}]},
'Cookie we overwrote using document.cookie is observed');
eventPromise = observeNextCookieChangeEvent();
await setCookieStringDocument('DOCUMENT-cookie=DELETED; path=/; max-age=0');
assert_equals(
await getCookieString(),
undefined,
@ -36,8 +54,104 @@ cookie_test(async t => {
undefined,
'Empty document.cookie cookie jar after document.cookie' +
' cookie-clearing using max-age=0');
await verifyCookieChangeEvent(
eventPromise, {deleted: [{name: 'DOCUMENT-cookie'}]},
'Deletion observed after document.cookie cookie-clearing' +
' using max-age=0');
}, 'document.cookie set/overwrite/delete observed by CookieStore');
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await cookieStore.set('DOCUMENT-cookie', 'value');
assert_equals(
await getCookieString(),
'DOCUMENT-cookie=value',
'Cookie we wrote using CookieStore in cookie jar');
assert_equals(
await getCookieStringHttp(),
'DOCUMENT-cookie=value',
'Cookie we wrote using CookieStore in HTTP cookie jar');
assert_equals(
await getCookieStringDocument(),
'DOCUMENT-cookie=value',
'Cookie we wrote using CookieStore in document.cookie');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'DOCUMENT-cookie', value: 'value'}]},
'Cookie we wrote using CookieStore is observed');
eventPromise = observeNextCookieChangeEvent();
await cookieStore.set('DOCUMENT-cookie', 'new-value');
assert_equals(
await getCookieString(),
'DOCUMENT-cookie=new-value',
'Cookie we overwrote using CookieStore in cookie jar');
assert_equals(
await getCookieStringHttp(),
'DOCUMENT-cookie=new-value',
'Cookie we overwrote using CookieStore in HTTP cookie jar');
assert_equals(
await getCookieStringDocument(),
'DOCUMENT-cookie=new-value',
'Cookie we overwrote using CookieStore in document.cookie');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'DOCUMENT-cookie', value: 'new-value'}]},
'Cookie we overwrote using CookieStore is observed');
eventPromise = observeNextCookieChangeEvent();
await cookieStore.delete('DOCUMENT-cookie');
assert_equals(
await getCookieString(),
undefined,
'Empty cookie jar after CookieStore delete');
assert_equals(
await getCookieStringHttp(),
undefined,
'Empty HTTP cookie jar after CookieStore delete');
assert_equals(
await getCookieStringDocument(),
undefined,
'Empty document.cookie cookie jar after CookieStore delete');
await verifyCookieChangeEvent(
eventPromise, {deleted: [{name: 'DOCUMENT-cookie'}]},
'Deletion observed after CookieStore delete');
}, 'CookieStore set/overwrite/delete observed by document.cookie');
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await setCookieStringDocument('DOCUMENT-🍪=🔵; path=/');
assert_equals(
await getCookieString(),
'DOCUMENT-🍪=🔵',
'Cookie we wrote using document.cookie in cookie jar');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'DOCUMENT-🍪', value: '🔵'}]},
'Cookie we wrote using document.cookie is observed');
eventPromise = observeNextCookieChangeEvent();
await setCookieStringDocument('DOCUMENT-🍪=DELETED; path=/; max-age=0');
assert_equals(
await getCookieString(),
undefined,
'Empty cookie jar after document.cookie' +
' cookie-clearing using max-age=0');
await verifyCookieChangeEvent(
eventPromise, {deleted: [{name: 'DOCUMENT-🍪'}]},
'Deletion observed after document.cookie cookie-clearing' +
' using max-age=0');
}, 'Verify interoperability of document.cookie with other APIs.');
}, 'CookieStore agrees with document.cookie on encoding non-ASCII cookies');
cookie_test(async t => {
await cookieStore.set('DOCUMENT-🍪', '🔵');
assert_equals(
await getCookieStringDocument(),
'DOCUMENT-🍪=🔵',
'Cookie we wrote using CookieStore in document.cookie');
await cookieStore.delete('DOCUMENT-🍪');
assert_equals(
await getCookieStringDocument(),
undefined,
'Empty cookie jar after CookieStore delete');
}, 'document.cookie agrees with CookieStore on encoding non-ASCII cookies');

74
tests/wpt/web-platform-tests/cookie-store/resources/get_set_get_all.js
View file

@ -1,74 +0,0 @@
'use strict';
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await cookieStore.set('TEST', 'value0');
assert_equals(
await getCookieString(),
'TEST=value0',
'Cookie jar contains only cookie we set');
assert_equals(
await getCookieStringHttp(),
'TEST=value0',
'HTTP cookie jar contains only cookie we set');
await verifyCookieChangeEvent(
eventPromise,
{changed: [{name: 'TEST', value: 'value0'}]},
'Observed value that was set');
eventPromise = observeNextCookieChangeEvent();
await cookieStore.set('TEST', 'value');
assert_equals(
await getCookieString(),
'TEST=value',
'Cookie jar contains only cookie we overwrote');
await verifyCookieChangeEvent(
eventPromise,
{changed: [{name: 'TEST', value: 'value'}]},
'Observed value that was overwritten');
let allCookies = await cookieStore.getAll();
assert_equals(
allCookies[0].name,
'TEST',
'First entry in allCookies should be named TEST');
assert_equals(
allCookies[0].value,
'value',
'First entry in allCookies should have value "value"');
assert_equals(
allCookies.length,
1,
'Only one cookie should exist in allCookies');
let firstCookie = await cookieStore.get();
assert_equals(
firstCookie.name,
'TEST',
'First cookie should be named TEST');
assert_equals(
firstCookie.value,
'value',
'First cookie should have value "value"');
let allCookies_TEST = await cookieStore.getAll('TEST');
assert_equals(
allCookies_TEST[0].name,
'TEST',
'First entry in allCookies_TEST should be named TEST');
assert_equals(
allCookies_TEST[0].value,
'value',
'First entry in allCookies_TEST should have value "value"');
assert_equals(
allCookies_TEST.length,
1,
'Only one cookie should exist in allCookies_TEST');
let firstCookie_TEST = await cookieStore.get('TEST');
assert_equals(
firstCookie_TEST.name,
'TEST',
'First TEST cookie should be named TEST');
assert_equals(
firstCookie_TEST.value,
'value',
'First TEST cookie should have value "value"');
}, 'Get/set/get all cookies in store');

177
tests/wpt/web-platform-tests/cookie-store/resources/http_cookie_and_set_cookie_headers.js
View file

@ -1,5 +1,50 @@
'use strict';
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp('HTTP-cookie=value; path=/');
assert_equals(
await getCookieString(),
'HTTP-cookie=value',
'Cookie we wrote using HTTP in cookie jar');
assert_equals(
await getCookieStringHttp(),
'HTTP-cookie=value',
'Cookie we wrote using HTTP in HTTP cookie jar');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'HTTP-cookie', value: 'value'}]},
'Cookie we wrote using HTTP is observed');
eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp('HTTP-cookie=new-value; path=/');
assert_equals(
await getCookieString(),
'HTTP-cookie=new-value',
'Cookie we overwrote using HTTP in cookie jar');
assert_equals(
await getCookieStringHttp(),
'HTTP-cookie=new-value',
'Cookie we overwrote using HTTP in HTTP cookie jar');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'HTTP-cookie', value: 'new-value'}]},
'Cookie we overwrote using HTTP is observed');
eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp('HTTP-cookie=DELETED; path=/; max-age=0');
assert_equals(
await getCookieString(),
undefined,
'Empty cookie jar after HTTP cookie-clearing using max-age=0');
assert_equals(
await getCookieStringHttp(),
undefined,
'Empty HTTP cookie jar after HTTP cookie-clearing using max-age=0');
await verifyCookieChangeEvent(
eventPromise, {deleted: [{name: 'HTTP-cookie'}]},
'Deletion observed after HTTP cookie-clearing using max-age=0');
}, 'HTTP set/overwrite/delete observed in CookieStore');
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp('HTTP-🍪=🔵; path=/');
@ -7,10 +52,6 @@ cookie_test(async t => {
await getCookieString(),
'HTTP-🍪=🔵',
'Cookie we wrote using HTTP in cookie jar');
assert_equals(
await getCookieStringHttp(),
'HTTP-🍪=🔵',
'Cookie we wrote using HTTP in HTTP cookie jar');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'HTTP-🍪', value: '🔵'}]},
'Cookie we wrote using HTTP is observed');
@ -20,78 +61,128 @@ cookie_test(async t => {
assert_equals(
await getCookieString(),
undefined,
'Empty cookie jar after HTTP cookie-clearing using max-age=0');
assert_equals(
await getCookieStringHttp(),
undefined,
'Empty HTTP cookie jar after HTTP cookie-clearing using max-age=0');
'Empty cookie jar after HTTP cookie-clearing using max-age=0');
await verifyCookieChangeEvent(
eventPromise, {deleted: [{name: 'HTTP-🍪'}]},
'Deletion observed after HTTP cookie-clearing using max-age=0');
await cookieStore.delete('HTTP-🍪');
}, 'Interoperability of HTTP Set-Cookie: with other APIs');
}, 'CookieStore agreed with HTTP headers agree on encoding non-ASCII cookies');
cookie_test(async t => {
let eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp('HTTPONLY-🍪=🔵; path=/; httponly');
await cookieStore.set('TEST', 'value0');
assert_equals(
await getCookieString(),
undefined,
'HttpOnly cookie we wrote using HTTP in cookie jar' +
' is invisible to script');
await getCookieString(),
'TEST=value0',
'Cookie jar contains only cookie we set');
assert_equals(
await getCookieStringHttp(),
'HTTPONLY-🍪=🔵',
'HttpOnly cookie we wrote using HTTP in HTTP cookie jar');
await getCookieStringHttp(),
'TEST=value0',
'HTTP cookie jar contains only cookie we set');
await verifyCookieChangeEvent(
eventPromise,
{changed: [{name: 'TEST', value: 'value0'}]},
'Observed value that was set');
eventPromise = observeNextCookieChangeEvent();
await setCookieStringHttp(
'HTTPONLY-🍪=DELETED; path=/; max-age=0; httponly');
await cookieStore.set('TEST', 'value');
assert_equals(
await getCookieString(),
undefined,
'Empty cookie jar after HTTP cookie-clearing using max-age=0');
await getCookieString(),
'TEST=value',
'Cookie jar contains only cookie we set');
assert_equals(
await getCookieStringHttp(),
undefined,
'Empty HTTP cookie jar after HTTP cookie-clearing using max-age=0');
// HTTPONLY cookie changes should not have been observed; perform
// a dummy change to verify that nothing else was queued up.
await cookieStore.set('TEST', 'dummy');
await getCookieStringHttp(),
'TEST=value',
'HTTP cookie jar contains only cookie we set');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'TEST', value: 'dummy'}]},
'HttpOnly cookie deletion was not observed');
}, 'HttpOnly cookies are not observed');
eventPromise,
{changed: [{name: 'TEST', value: 'value'}]},
'Observed value that was overwritten');
eventPromise = observeNextCookieChangeEvent();
await cookieStore.delete('TEST');
assert_equals(
await getCookieString(),
undefined,
'Cookie jar does not contain cookie we deleted');
assert_equals(
await getCookieStringHttp(),
undefined,
'HTTP cookie jar does not contain cookie we deleted');
await verifyCookieChangeEvent(
eventPromise,
{deleted: [{name: 'TEST'}]},
'Observed cookie that was deleted');
}, 'CookieStore set/overwrite/delete observed in HTTP headers');
cookie_test(async t => {
await cookieStore.set('🍪', '🔵');
assert_equals(
await getCookieStringHttp(),
'🍪=🔵',
'HTTP cookie jar contains only cookie we set');
await cookieStore.delete('🍪');
assert_equals(
await getCookieStringHttp(),
undefined,
'HTTP cookie jar does not contain cookie we deleted');
}, 'HTTP headers agreed with CookieStore on encoding non-ASCII cookies');
cookie_test(async t => {
// Non-UTF-8 byte sequences cause the Set-Cookie to be dropped.
let eventPromise = observeNextCookieChangeEvent();
await setCookieBinaryHttp(
unescape(encodeURIComponent('HTTP-🍪=🔵')) + '\xef\xbf\xbd; path=/');
unescape(encodeURIComponent('HTTP-cookie=value')) + '\xef\xbf\xbd; path=/');
assert_equals(
await getCookieString(),
'HTTP-🍪=🔵\ufffd',
'HTTP-cookie=value\ufffd',
'Binary cookie we wrote using HTTP in cookie jar');
assert_equals(
await getCookieStringHttp(),
'HTTP-🍪=🔵\ufffd',
'HTTP-cookie=value\ufffd',
'Binary cookie we wrote using HTTP in HTTP cookie jar');
assert_equals(
decodeURIComponent(escape(await getCookieBinaryHttp())),
'HTTP-🍪=🔵\ufffd',
'HTTP-cookie=value\ufffd',
'Binary cookie we wrote in binary HTTP cookie jar');
assert_equals(
await getCookieBinaryHttp(),
unescape(encodeURIComponent('HTTP-🍪=🔵')) + '\xef\xbf\xbd',
unescape(encodeURIComponent('HTTP-cookie=value')) + '\xef\xbf\xbd',
'Binary cookie we wrote in binary HTTP cookie jar');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'HTTP-🍪', value: '🔵\ufffd'}]},
eventPromise, {changed: [{name: 'HTTP-cookie', value: 'value\ufffd'}]},
'Binary cookie we wrote using HTTP is observed');
eventPromise = observeNextCookieChangeEvent();
await setCookieBinaryHttp(
unescape(encodeURIComponent('HTTP-🍪=DELETED; path=/; max-age=0')));
unescape(encodeURIComponent('HTTP-cookie=new-value')) + '\xef\xbf\xbd; path=/');
assert_equals(
await getCookieString(),
'HTTP-cookie=new-value\ufffd',
'Binary cookie we overwrote using HTTP in cookie jar');
assert_equals(
await getCookieStringHttp(),
'HTTP-cookie=new-value\ufffd',
'Binary cookie we overwrote using HTTP in HTTP cookie jar');
assert_equals(
decodeURIComponent(escape(await getCookieBinaryHttp())),
'HTTP-cookie=new-value\ufffd',
'Binary cookie we overwrote in binary HTTP cookie jar');
assert_equals(
await getCookieBinaryHttp(),
unescape(encodeURIComponent('HTTP-cookie=new-value')) + '\xef\xbf\xbd',
'Binary cookie we overwrote in binary HTTP cookie jar');
await verifyCookieChangeEvent(
eventPromise, {changed: [{name: 'HTTP-cookie', value: 'new-value\ufffd'}]},
'Binary cookie we overwrote using HTTP is observed');
eventPromise = observeNextCookieChangeEvent();
await setCookieBinaryHttp(
unescape(encodeURIComponent('HTTP-cookie=DELETED; path=/; max-age=0')));
assert_equals(
await getCookieString(),
undefined,
@ -107,6 +198,6 @@ cookie_test(async t => {
'Empty binary HTTP cookie jar after' +
' binary HTTP cookie-clearing using max-age=0');
await verifyCookieChangeEvent(
eventPromise, {deleted: [{name: 'HTTP-🍪'}]},
eventPromise, {deleted: [{name: 'HTTP-cookie'}]},
'Deletion observed after binary HTTP cookie-clearing using max-age=0');
}, 'Binary HTTP cookies');
}, 'Binary HTTP set/overwrite/delete observed in CookieStore');

30
tests/wpt/web-platform-tests/cookie-store/resources/ordering.js
View file

@ -1,40 +1,38 @@
'use strict';
// TODO(jsbell): Does this test really need simple origin ('__Host-') cookies?
cookie_test(async t => {
await cookieStore.set('__Host-1🍪', '🔵cookie-value1🔴');
await cookieStore.set('__Host-2🌟', '🌠cookie-value2🌠');
await cookieStore.set('__Host-3🌱', '🔶cookie-value3🔷');
await cookieStore.set('ordered-1', 'cookie-value1');
await cookieStore.set('ordered-2', 'cookie-value2');
await cookieStore.set('ordered-3', 'cookie-value3');
// NOTE: this assumes no concurrent writes from elsewhere; it also
// uses three separate cookie jar read operations where a single getAll
// would be more efficient, but this way the CookieStore does the filtering
// for us.
const matchingValues = await Promise.all([ '1🍪', '2🌟', '3🌱' ].map(
async suffix => (await cookieStore.get('__Host-' + suffix)).value));
const matchingValues = await Promise.all(['1', '2', '3'].map(
async suffix => (await cookieStore.get('ordered-' + suffix)).value));
const actual = matchingValues.join(';');
const expected = '🔵cookie-value1🔴;🌠cookie-value2🌠;🔶cookie-value3🔷';
const expected = 'cookie-value1;cookie-value2;cookie-value3';
assert_equals(actual, expected);
}, 'Set three simple origin session cookies sequentially and ensure ' +
'they all end up in the cookie jar in order.');
cookie_test(async t => {
await Promise.all([
cookieStore.set('__Host-unordered1🍪', '🔵unordered-cookie-value1🔴'),
cookieStore.set('__Host-unordered2🌟', '🌠unordered-cookie-value2🌠'),
cookieStore.set('__Host-unordered3🌱', '🔶unordered-cookie-value3🔷')
cookieStore.set('ordered-unordered1', 'unordered-cookie-value1'),
cookieStore.set('ordered-unordered2', 'unordered-cookie-value2'),
cookieStore.set('ordered-unordered3', 'unordered-cookie-value3')
]);
// NOTE: this assumes no concurrent writes from elsewhere; it also
// uses three separate cookie jar read operations where a single getAll
// would be more efficient, but this way the CookieStore does the filtering
// for us and we do not need to sort.
const matchingCookies = await Promise.all([ '1🍪', '2🌟', '3🌱' ].map(
suffix => cookieStore.get('__Host-unordered' + suffix)));
const matchingCookies = await Promise.all(['1', '2', '3'].map(
suffix => cookieStore.get('ordered-unordered' + suffix)));
const actual = matchingCookies.map(({ value }) => value).join(';');
const expected =
'🔵unordered-cookie-value1🔴;' +
'🌠unordered-cookie-value2🌠;' +
'🔶unordered-cookie-value3🔷';
'unordered-cookie-value1;' +
'unordered-cookie-value2;' +
'unordered-cookie-value3';
assert_equals(actual, expected);
}, 'Set three simple origin session cookies in undefined order using ' +
'Promise.all and ensure they all end up in the cookie jar in any ' +