tor-browser

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

cookieStore_delete_arguments.https.any.js (9419B)

      1 // META: title=Cookie Store API: cookieStore.delete() arguments
      2 // META: script=resources/cookie-test-helpers.js
      3 // META: global=window,serviceworker
      4 
      5 'use strict';
      6 const MAX_COOKIE_NAME_SIZE = 4096;
      7 
      8 promise_test(async testCase => {
      9  await cookieStore.set('cookie-name', 'cookie-value');
     10  testCase.add_cleanup(async () => {
     11    await setCookieStringHttp(`cookie-name=deleted; Max-Age=0`);
     12  });
     13  await cookieStore.delete('cookie-name');
     14  const cookie = await cookieStore.get('cookie-name');
     15  assert_equals(cookie, null);
     16 }, 'cookieStore.delete with positional name');
     17 
     18 promise_test(async testCase => {
     19  await cookieStore.set('cookie-name', 'cookie-value');
     20  testCase.add_cleanup(async () => {
     21    await setCookieStringHttp(`cookie-name=deleted; Max-Age=0`);
     22  });
     23 
     24  await cookieStore.delete({ name: 'cookie-name' });
     25  const cookie = await cookieStore.get('cookie-name');
     26  assert_equals(cookie, null);
     27 }, 'cookieStore.delete with name in options');
     28 
     29 promise_test(async testCase => {
     30  const currentUrl = new URL(self.location.href);
     31  const currentDomain = currentUrl.hostname;
     32 
     33  await promise_rejects_js(testCase, TypeError, cookieStore.set(
     34      { name: 'cookie-name', value: 'cookie-value',
     35        domain: `.${currentDomain}` }));
     36 }, 'cookieStore.delete domain starts with "."');
     37 
     38 promise_test(async testCase => {
     39  await promise_rejects_js(testCase, TypeError, cookieStore.set(
     40      { name: 'cookie-name', value: 'cookie-value', domain: 'example.com' }));
     41 }, 'cookieStore.delete with domain that is not equal current host');
     42 
     43 promise_test(async testCase => {
     44  const currentUrl = new URL(self.location.href);
     45  const currentDomain = currentUrl.hostname;
     46  await cookieStore.set(
     47      { name: 'cookie-name', value: 'cookie-value', domain: currentDomain });
     48  testCase.add_cleanup(async () => {
     49    await setCookieStringHttp(`cookie-name=deleted; Domain=${currentDomain}; Max-Age=0`);
     50  });
     51 
     52  await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
     53  const cookie = await cookieStore.get('cookie-name');
     54  assert_equals(cookie, null);
     55 }, 'cookieStore.delete with domain set to the current hostname');
     56 
     57 promise_test(async testCase => {
     58  const currentUrl = new URL(self.location.href);
     59  const currentDomain = currentUrl.hostname;
     60  const subDomain = `sub.${currentDomain}`;
     61 
     62  await promise_rejects_js(testCase, TypeError, cookieStore.delete(
     63      { name: 'cookie-name', domain: subDomain }));
     64 }, 'cookieStore.delete with domain set to a subdomain of the current hostname');
     65 
     66 promise_test(async testCase => {
     67  const currentUrl = new URL(self.location.href);
     68  const currentDomain = currentUrl.hostname;
     69  assert_not_equals(currentDomain[0] === '.',
     70      'this test assumes that the current hostname does not start with .');
     71  const domainSuffix = currentDomain.substr(1);
     72 
     73  await promise_rejects_js(testCase, TypeError, cookieStore.delete(
     74      { name: 'cookie-name', domain: domainSuffix }));
     75 }, 'cookieStore.delete with domain set to a non-domain-matching suffix of ' +
     76   'the current hostname');
     77 
     78 promise_test(async testCase => {
     79  const currentUrl = new URL(self.location.href);
     80  const currentPath = currentUrl.pathname;
     81  const currentDirectory =
     82      currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
     83  await cookieStore.set(
     84      { name: 'cookie-name', value: 'cookie-value', path: currentDirectory });
     85  testCase.add_cleanup(async () => {
     86    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}; Max-Age=0`);
     87    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}/; Max-Age=0`);
     88  });
     89 
     90  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
     91  const cookie = await cookieStore.get('cookie-name');
     92  assert_equals(cookie, null);
     93 }, 'cookieStore.delete with path set to the current directory');
     94 
     95 promise_test(async testCase => {
     96  const currentUrl = new URL(self.location.href);
     97  const currentPath = currentUrl.pathname;
     98  const currentDirectory =
     99      currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
    100  const subDirectory = currentDirectory + "subdir/";
    101  await cookieStore.set(
    102      { name: 'cookie-name', value: 'cookie-value', path: currentDirectory });
    103  testCase.add_cleanup(async () => {
    104    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}; Max-Age=0`);
    105    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}/; Max-Age=0`);
    106  });
    107 
    108  await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
    109  const cookie = await cookieStore.get('cookie-name');
    110  assert_equals(cookie.name, 'cookie-name');
    111  assert_equals(cookie.value, 'cookie-value');
    112 }, 'cookieStore.delete with path set to subdirectory of the current directory');
    113 
    114 promise_test(async testCase => {
    115  const currentUrl = new URL(self.location.href);
    116  const currentPath = currentUrl.pathname;
    117  const currentDirectory = currentPath.substr(0, currentPath.lastIndexOf('/'));
    118  await setCookieStringHttp(`cookie-name=cookie-value; Path=${currentDirectory};`);
    119 
    120  testCase.add_cleanup(async () => {
    121    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}; Max-Age=0`);
    122    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}/; Max-Age=0`);
    123  });
    124 
    125  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
    126  const cookie = await cookieStore.get('cookie-name');
    127  assert_equals(cookie, null);
    128 }, 'cookieStore.delete does not append / at the end of path');
    129 
    130 promise_test(async testCase => {
    131  if (typeof self.document === 'undefined') {
    132    // The test is being run from a service worker context where document is undefined
    133    testCase.done();
    134    return;
    135  }
    136  const currentUrl = new URL(self.location.href);
    137  const currentPath = currentUrl.pathname;
    138  const currentDirectory = currentPath.substr(0, currentPath.lastIndexOf('/'));
    139  await setCookieStringDocument('cookie-name=cookie-value; path=' + currentDirectory);
    140  testCase.add_cleanup(async () => {
    141    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}; Max-Age=0`);
    142    await setCookieStringHttp(`cookie-name=deleted; Path=${currentDirectory}/; Max-Age=0`);
    143  });
    144  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
    145  const cookie = await cookieStore.get('cookie-name');
    146  assert_equals(cookie, null);
    147 }, 'cookieStore.delete can delete a cookie set by document.cookie if document is defined');
    148 
    149 promise_test(async testCase => {
    150  const currentUrl = new URL(self.location.href);
    151  const currentPath = currentUrl.pathname;
    152  const currentDirectory =
    153      currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
    154  const invalidPath = currentDirectory.substr(1);
    155 
    156  await promise_rejects_js(testCase, TypeError, cookieStore.delete(
    157      { name: 'cookie-name', path: invalidPath }));
    158 }, 'cookieStore.delete with path that does not start with /');
    159 
    160 promise_test(async testCase => {
    161  await cookieStore.set('cookie-name', 'cookie-value');
    162  testCase.add_cleanup(async () => {
    163    await setCookieStringHttp(`cookie-name=deleted; Max-Age=0`);
    164  });
    165 
    166  const cookie_attributes = await cookieStore.get('cookie-name');
    167  assert_equals(cookie_attributes.name, 'cookie-name');
    168  assert_equals(cookie_attributes.value, 'cookie-value');
    169 
    170  await cookieStore.delete(cookie_attributes.name);
    171  const cookie = await cookieStore.get('cookie-name');
    172  assert_equals(cookie, null);
    173 }, 'cookieStore.delete with get result');
    174 
    175 promise_test(async testCase => {
    176  await cookieStore.set('', 'cookie-value');
    177  testCase.add_cleanup(async () => {
    178    await setCookieStringHttp(`=deleted; Max-Age=0`);
    179  });
    180 
    181  await cookieStore.delete('');
    182  const cookie = await cookieStore.get('');
    183  assert_equals(cookie, null);
    184 }, 'cookieStore.delete with positional empty name');
    185 
    186 promise_test(async testCase => {
    187  await cookieStore.set('', 'cookie-value');
    188  testCase.add_cleanup(async () => {
    189    await setCookieStringHttp(`=deleted; Max-Age=0`);
    190  });
    191 
    192  await cookieStore.delete({ name: '' });
    193  const cookie = await cookieStore.get('');
    194  assert_equals(cookie, null);
    195 }, 'cookieStore.delete with empty name in options');
    196 
    197 promise_test(async testCase => {
    198  const cookieName = 't'.repeat(MAX_COOKIE_NAME_SIZE);
    199  await cookieStore.set(cookieName, '');
    200  testCase.add_cleanup(async () => {
    201    await setCookieStringHttp(cookieName + '=; Max-Age=0');
    202  });
    203 
    204  await cookieStore.delete({name: cookieName});
    205  const cookie = await cookieStore.get(cookieName);
    206  assert_equals(cookie, null);
    207 }, 'cookieStore.delete with maximum cookie name size');
    208 
    209 promise_test(async testCase => {
    210  // Cookies having a __Host- prefix are not allowed to specify a domain
    211  await cookieStore.delete('cookie-name');
    212 
    213  const currentUrl = new URL(self.location.href);
    214  const currentDomain = currentUrl.hostname;
    215 
    216  await promise_rejects_js(testCase, TypeError, cookieStore.delete(
    217      { name: '__Host-cookie-name',
    218        value: 'cookie-value',
    219        domain: currentDomain }));
    220  const cookie = await cookieStore.get('cookie-name');
    221  assert_equals(cookie, null);
    222 }, 'cookieStore.delete with a __Host- prefix should not have a domain');
    223 
    224 promise_test(async testCase => {
    225  await cookieStore.set('cookie-name', 'cookie-value');
    226  testCase.add_cleanup(async () => {
    227    await cookieStore.delete('cookie-name');
    228  });
    229  const cookie = await cookieStore.delete(' cookie-name \t');
    230  assert_equals(cookie, undefined);
    231 }, 'cookieStore.delete with whitespace');