tor-browser

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

cookieStore_get_arguments.https.any.js (5316B)

      1 // META: title=Cookie Store API: cookieStore.get() arguments
      2 // META: global=window,serviceworker
      3 
      4 'use strict';
      5 
      6 promise_test(async testCase => {
      7  await cookieStore.set('cookie-name', 'cookie-value');
      8  testCase.add_cleanup(async () => {
      9    await cookieStore.delete('cookie-name');
     10  });
     11 
     12  await promise_rejects_js(testCase, TypeError, cookieStore.get());
     13 }, 'cookieStore.get with no arguments returns TypeError');
     14 
     15 promise_test(async testCase => {
     16  await cookieStore.set('cookie-name', 'cookie-value');
     17  testCase.add_cleanup(async () => {
     18    await cookieStore.delete('cookie-name');
     19  });
     20 
     21  await promise_rejects_js(testCase, TypeError, cookieStore.get({}));
     22 },'cookieStore.get with empty options returns TypeError');
     23 
     24 promise_test(async testCase => {
     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 }, 'cookieStore.get with positional name');
     34 
     35 promise_test(async testCase => {
     36  await cookieStore.set('cookie-name', 'cookie-value');
     37  testCase.add_cleanup(async () => {
     38    await cookieStore.delete('cookie-name');
     39  });
     40 
     41  const cookie = await cookieStore.get({ name: 'cookie-name' });
     42  assert_equals(cookie.name, 'cookie-name');
     43  assert_equals(cookie.value, 'cookie-value');
     44 }, 'cookieStore.get with name in options');
     45 
     46 promise_test(async testCase => {
     47  await cookieStore.set('cookie-name', 'cookie-value');
     48  testCase.add_cleanup(async () => {
     49    await cookieStore.delete('cookie-name');
     50  });
     51 
     52  const cookie = await cookieStore.get('cookie-name',
     53                                       { name: 'wrong-cookie-name' });
     54  assert_equals(cookie.name, 'cookie-name');
     55  assert_equals(cookie.value, 'cookie-value');
     56 }, 'cookieStore.get with name in both positional arguments and options');
     57 
     58 promise_test(async testCase => {
     59  await cookieStore.set('cookie-name', 'cookie-value');
     60  testCase.add_cleanup(async () => {
     61    await cookieStore.delete('cookie-name');
     62  });
     63 
     64  let target_url = self.location.href;
     65  if (self.GLOBAL.isWorker()) {
     66    target_url = target_url + '/path/within/scope';
     67  }
     68 
     69  const cookie = await cookieStore.get({ url: target_url });
     70  assert_equals(cookie.name, 'cookie-name');
     71  assert_equals(cookie.value, 'cookie-value');
     72 }, 'cookieStore.get with absolute url in options');
     73 
     74 promise_test(async testCase => {
     75  await cookieStore.set('cookie-name', 'cookie-value');
     76  testCase.add_cleanup(async () => {
     77    await cookieStore.delete('cookie-name');
     78  });
     79 
     80  let target_path = self.location.pathname;
     81  if (self.GLOBAL.isWorker()) {
     82    target_path = target_path + '/path/within/scope';
     83  }
     84 
     85  const cookie = await cookieStore.get({ url: target_path });
     86  assert_equals(cookie.name, 'cookie-name');
     87  assert_equals(cookie.value, 'cookie-value');
     88 }, 'cookieStore.get with relative url in options');
     89 
     90 if (!self.GLOBAL.isWorker()) {
     91  promise_test(async testCase => {
     92    const invalid_url =
     93        `${self.location.protocol}//${self.location.host}/different/path`;
     94    await promise_rejects_js(testCase, TypeError, cookieStore.get(
     95        { url: invalid_url }));
     96  }, 'cookieStore.get with invalid url path in options');
     97 } else {
     98  promise_test(async testCase => {
     99    const sameorigin_url =
    100        `${self.location.protocol}//${self.location.host}/different/path`;
    101    assert_true(await cookieStore.get({ url: sameorigin_url }) === null);
    102  }, 'cookieStore.get with same-origin url path in options');
    103 }
    104 
    105 promise_test(async testCase => {
    106  const invalid_url =
    107      `${self.location.protocol}//www.example.com${self.location.pathname}`;
    108  await promise_rejects_js(testCase, TypeError, cookieStore.get(
    109      { url: invalid_url }));
    110 }, 'cookieStore.get with invalid url host in options');
    111 
    112 promise_test(async testCase => {
    113  await cookieStore.set('cookie-name', 'cookie-value');
    114  testCase.add_cleanup(async () => {
    115    await cookieStore.delete('cookie-name');
    116  });
    117 
    118  let target_url = self.location.href;
    119  if (self.GLOBAL.isWorker()) {
    120    target_url = target_url + '/path/within/scope';
    121  }
    122 
    123  target_url = target_url + "#foo";
    124 
    125  const cookie = await cookieStore.get({ url: target_url });
    126  assert_equals(cookie.name, 'cookie-name');
    127  assert_equals(cookie.value, 'cookie-value');
    128 }, 'cookieStore.get with absolute url with fragment in options');
    129 
    130 promise_test(async testCase => {
    131  if (!self.GLOBAL.isWorker()) {
    132    await cookieStore.set('cookie-name', 'cookie-value');
    133    testCase.add_cleanup(async () => {
    134      await cookieStore.delete('cookie-name');
    135    });
    136 
    137    self.location = "#foo";
    138    let target_url = self.location.href;
    139 
    140    const cookie = await cookieStore.get({ url: target_url });
    141    assert_equals(cookie.name, 'cookie-name');
    142    assert_equals(cookie.value, 'cookie-value');
    143  }
    144 }, 'cookieStore.get with absolute different url in options');
    145 
    146 promise_test(async testCase => {
    147  await cookieStore.set('cookie-name', 'cookie-value');
    148  testCase.add_cleanup(async () => {
    149    await cookieStore.delete('cookie-name');
    150  });
    151  const cookie = await cookieStore.get(' cookie-name \t');
    152  assert_equals(cookie.name, 'cookie-name');
    153  assert_equals(cookie.value, 'cookie-value');
    154 }, 'cookieStore.get with whitespace');