tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

cookieListItem_attributes.https.window.js (8402B)

      1 // META: title=Cookie Store API: cookieListItem attributes
      2 // META: script=/resources/testdriver.js
      3 // META: script=/resources/testdriver-vendor.js
      4 
      5 // Please keep this synchronized with cookieListItem_attributes.https.any.js.
      6 
      7 'use strict';
      8 
      9 const currentHostname = location.hostname;
     10 
     11 const oneDayInSeconds = 24 * 60 * 60;
     12 const fourHundredDaysInSeconds = 400 * oneDayInSeconds;
     13 const tenYearsInSeconds = 10 * 365 * oneDayInSeconds;
     14 const fourHundredDaysFromNowInSeconds = Date.now() / 1000 + fourHundredDaysInSeconds;
     15 const tenYearsFromNowInSeconds = Date.now() / 1000 + tenYearsInSeconds;
     16 
     17 function assert_cookie_keys(cookie) {
     18  const cookieKeys = Object.keys(cookie);
     19  assert_array_equals(cookieKeys, ['name', 'value']);
     20 }
     21 
     22 promise_test(async testCase => {
     23  await cookieStore.delete('cookie-name');
     24 
     25  await cookieStore.set('cookie-name', 'cookie-value');
     26  testCase.add_cleanup(async () => {
     27    await cookieStore.delete('cookie-name');
     28  });
     29 
     30  const cookie = await cookieStore.get('cookie-name');
     31  assert_equals(cookie.name, 'cookie-name');
     32  assert_equals(cookie.value, 'cookie-value');
     33  assert_cookie_keys(cookie);
     34 
     35  const internalCookie = await test_driver.get_named_cookie('cookie-name');
     36  assert_equals(internalCookie.name, 'cookie-name');
     37  assert_equals(internalCookie.value, 'cookie-value');
     38  assert_equals(internalCookie.path, '/');
     39  assert_equals(internalCookie.domain, currentHostname);
     40  assert_true(internalCookie.secure);
     41  assert_false(internalCookie.httpOnly);
     42  assert_equals(internalCookie.expiry, undefined);
     43  assert_equals(internalCookie.sameSite, 'Strict');
     44 }, 'CookieListItem - cookieStore.set defaults with positional name and value');
     45 
     46 promise_test(async testCase => {
     47  await cookieStore.delete('cookie-name');
     48 
     49  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value' });
     50  testCase.add_cleanup(async () => {
     51    await cookieStore.delete('cookie-name');
     52  });
     53  const cookie = await cookieStore.get('cookie-name');
     54  assert_equals(cookie.name, 'cookie-name');
     55  assert_equals(cookie.value, 'cookie-value');
     56  assert_cookie_keys(cookie);
     57 
     58  const internalCookie = await test_driver.get_named_cookie('cookie-name');
     59  assert_equals(internalCookie.name, 'cookie-name');
     60  assert_equals(internalCookie.value, 'cookie-value');
     61  assert_equals(internalCookie.path, '/');
     62  assert_equals(internalCookie.domain, currentHostname);
     63  assert_true(internalCookie.secure);
     64  assert_false(internalCookie.httpOnly);
     65  assert_equals(internalCookie.expiry, undefined);
     66  assert_equals(internalCookie.sameSite, 'Strict');
     67 }, 'CookieListItem - cookieStore.set defaults with name and value in options');
     68 
     69 promise_test(async testCase => {
     70  await cookieStore.delete('cookie-name');
     71 
     72  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
     73                          expires: tenYearsFromNowInSeconds * 1000 });
     74  testCase.add_cleanup(async () => {
     75    await cookieStore.delete('cookie-name');
     76  });
     77  const cookie = await cookieStore.get('cookie-name');
     78  assert_equals(cookie.name, 'cookie-name');
     79  assert_equals(cookie.value, 'cookie-value');
     80  assert_cookie_keys(cookie);
     81 
     82  const internalCookie = await test_driver.get_named_cookie('cookie-name');
     83  assert_approx_equals(internalCookie.expiry, fourHundredDaysFromNowInSeconds, oneDayInSeconds);
     84 }, 'CookieListItem - cookieStore.set with expires set to a timestamp 10 ' +
     85   'years in the future');
     86 
     87 promise_test(async testCase => {
     88  await cookieStore.delete('cookie-name');
     89 
     90  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
     91                          expires: new Date(tenYearsFromNowInSeconds) * 1000 });
     92  testCase.add_cleanup(async () => {
     93    await cookieStore.delete('cookie-name');
     94  });
     95  const cookie = await cookieStore.get('cookie-name');
     96  assert_equals(cookie.name, 'cookie-name');
     97  assert_equals(cookie.value, 'cookie-value');
     98  assert_cookie_keys(cookie);
     99 
    100  const internalCookie = await test_driver.get_named_cookie('cookie-name');
    101  assert_approx_equals(internalCookie.expiry, fourHundredDaysFromNowInSeconds, oneDayInSeconds);
    102 }, 'CookieListItem - cookieStore.set with expires set to a Date 10 ' +
    103   'years in the future');
    104 
    105 promise_test(async testCase => {
    106  await cookieStore.delete({ name: 'cookie-name', domain: currentHostname });
    107 
    108  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
    109                          domain: currentHostname });
    110  testCase.add_cleanup(async () => {
    111    await cookieStore.delete({ name: 'cookie-name', domain: currentHostname });
    112  });
    113  const cookie = await cookieStore.get('cookie-name');
    114  assert_equals(cookie.name, 'cookie-name');
    115  assert_equals(cookie.value, 'cookie-value');
    116  assert_cookie_keys(cookie);
    117 
    118  const internalCookie = await test_driver.get_named_cookie('cookie-name');
    119  assert_equals(internalCookie.domain, currentHostname);
    120 }, 'CookieListItem - cookieStore.set with domain set to the current hostname');
    121 
    122 promise_test(async testCase => {
    123  const currentUrl = new URL(self.location.href);
    124  const currentPath = currentUrl.pathname;
    125  const currentDirectory =
    126      currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
    127  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
    128 
    129  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
    130                          path: currentDirectory });
    131  testCase.add_cleanup(async () => {
    132    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
    133  });
    134  const cookie = await cookieStore.get('cookie-name');
    135  assert_equals(cookie.name, 'cookie-name');
    136  assert_equals(cookie.value, 'cookie-value');
    137  assert_cookie_keys(cookie);
    138 
    139  const internalCookie = await test_driver.get_named_cookie('cookie-name');
    140  assert_equals(internalCookie.path, currentDirectory);
    141 }, 'CookieListItem - cookieStore.set with path set to the current directory');
    142 
    143 promise_test(async testCase => {
    144  const currentUrl = new URL(self.location.href);
    145  const currentPath = currentUrl.pathname;
    146  const currentDirectory = currentPath.substr(0, currentPath.lastIndexOf('/'));
    147  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
    148 
    149  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
    150                          path: currentDirectory });
    151  testCase.add_cleanup(async () => {
    152    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
    153  });
    154  const cookie = await cookieStore.get('cookie-name');
    155  assert_equals(cookie.name, 'cookie-name');
    156  assert_equals(cookie.value, 'cookie-value');
    157  assert_cookie_keys(cookie);
    158 
    159  const internalCookie = await test_driver.get_named_cookie('cookie-name');
    160  assert_equals(internalCookie.path, currentDirectory);
    161 }, 'CookieListItem - cookieStore.set does not add / to path if it does not end with /');
    162 
    163 ['strict', 'lax', 'none'].forEach(sameSiteValue => {
    164  promise_test(async testCase => {
    165    await cookieStore.delete('cookie-name');
    166 
    167    await cookieStore.set({
    168        name: 'cookie-name', value: 'cookie-value', sameSite: sameSiteValue });
    169    testCase.add_cleanup(async () => {
    170      await cookieStore.delete('cookie-name');
    171    });
    172    const cookie = await cookieStore.get('cookie-name');
    173    assert_equals(cookie.name, 'cookie-name');
    174    assert_equals(cookie.value, 'cookie-value');
    175    assert_cookie_keys(cookie);
    176 
    177    const internalCookie = await test_driver.get_named_cookie('cookie-name');
    178    assert_equals(internalCookie.sameSite, sameSiteValue.charAt(0).toUpperCase() + sameSiteValue.slice(1));
    179  }, `CookieListItem - cookieStore.set with sameSite set to ${sameSiteValue}`);
    180 
    181 });
    182 
    183 promise_test(async testCase => {
    184  await cookieStore.delete('cookie-name');
    185  testCase.add_cleanup(async () => {
    186    await cookieStore.delete('cookie-name');
    187  });
    188 
    189  let encodedCookie = encodeURIComponent(JSON.stringify("cookie-name=1; max-age=99999999999999999999999999999; path=/"));
    190  await fetch(`/cookies/resources/cookie.py?set=${encodedCookie}`);
    191 
    192  assert_equals(document.cookie, "cookie-name=1", 'The cookie was set as expected.');
    193 
    194  const cookie = await cookieStore.get('cookie-name');
    195  assert_equals(cookie.name, 'cookie-name');
    196  assert_equals(cookie.value, '1');
    197  assert_cookie_keys(cookie);
    198 
    199  const internalCookie = await test_driver.get_named_cookie('cookie-name');
    200  assert_approx_equals(internalCookie.expiry, fourHundredDaysFromNowInSeconds, oneDayInSeconds);
    201 }, "Test max-age attribute over the 400 days");