tor-browser

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

worker-dedicated-importscripts.https.sub.html (9393B)


      1 <!DOCTYPE html>
      2 <!--
      3 This test was procedurally generated. Please do not modify it directly.
      4 Sources:
      5 - fetch/metadata/tools/fetch-metadata.conf.yml
      6 - fetch/metadata/tools/templates/worker-dedicated-importscripts.sub.html
      7 -->
      8 <html lang="en">
      9  <meta charset="utf-8">
     10  <title>HTTP headers on request for dedicated worker via the "importScripts" API</title>
     11  <script src="/resources/testharness.js"></script>
     12  <script src="/resources/testharnessreport.js"></script>
     13  <script src="/fetch/metadata/resources/helper.sub.js"></script>
     14  <script type="module">
     15  'use strict';
     16  function induceRequest(url, options) {
     17    const src = `
     18      importScripts('${url}');
     19      postMessage('done');
     20    `;
     21    const workerUrl = URL.createObjectURL(
     22      new Blob([src], { type: 'application/javascript' })
     23    );
     24    return new Promise((resolve, reject) => {
     25      const worker = new Worker(workerUrl, options);
     26      worker.onmessage = resolve;
     27      worker.onerror = reject;
     28    });
     29  }
     30 
     31  promise_test(() => {
     32    const key = '{{uuid()}}';
     33    const url = makeRequestURL(
     34      key, ['httpsOrigin'], { mime: 'application/javascript' }
     35    );
     36 
     37    return induceRequest(url)
     38      .then(() => retrieve(key))
     39      .then((headers) => {
     40          assert_own_property(headers, 'sec-fetch-site');
     41          assert_array_equals(headers['sec-fetch-site'], ['same-origin']);
     42        });
     43  }, 'sec-fetch-site - Same origin');
     44 
     45  promise_test(() => {
     46    const key = '{{uuid()}}';
     47    const url = makeRequestURL(
     48      key, ['httpsCrossSite'], { mime: 'application/javascript' }
     49    );
     50 
     51    return induceRequest(url)
     52      .then(() => retrieve(key))
     53      .then((headers) => {
     54          assert_own_property(headers, 'sec-fetch-site');
     55          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
     56        });
     57  }, 'sec-fetch-site - Cross-site');
     58 
     59  promise_test(() => {
     60    const key = '{{uuid()}}';
     61    const url = makeRequestURL(
     62      key, ['httpsSameSite'], { mime: 'application/javascript' }
     63    );
     64 
     65    return induceRequest(url)
     66      .then(() => retrieve(key))
     67      .then((headers) => {
     68          assert_own_property(headers, 'sec-fetch-site');
     69          assert_array_equals(headers['sec-fetch-site'], ['same-site']);
     70        });
     71  }, 'sec-fetch-site - Same site');
     72 
     73  promise_test(() => {
     74    const key = '{{uuid()}}';
     75    const url = makeRequestURL(
     76      key, ['httpsOrigin', 'httpsCrossSite', 'httpsOrigin'], { mime: 'application/javascript' }
     77    );
     78 
     79    return induceRequest(url)
     80      .then(() => retrieve(key))
     81      .then((headers) => {
     82          assert_own_property(headers, 'sec-fetch-site');
     83          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
     84        });
     85  }, 'sec-fetch-site - Same-Origin -> Cross-Site -> Same-Origin redirect');
     86 
     87  promise_test(() => {
     88    const key = '{{uuid()}}';
     89    const url = makeRequestURL(
     90      key, ['httpsOrigin', 'httpsSameSite', 'httpsOrigin'], { mime: 'application/javascript' }
     91    );
     92 
     93    return induceRequest(url)
     94      .then(() => retrieve(key))
     95      .then((headers) => {
     96          assert_own_property(headers, 'sec-fetch-site');
     97          assert_array_equals(headers['sec-fetch-site'], ['same-site']);
     98        });
     99  }, 'sec-fetch-site - Same-Origin -> Same-Site -> Same-Origin redirect');
    100 
    101  promise_test(() => {
    102    const key = '{{uuid()}}';
    103    const url = makeRequestURL(
    104      key, ['httpsCrossSite', 'httpsOrigin'], { mime: 'application/javascript' }
    105    );
    106 
    107    return induceRequest(url)
    108      .then(() => retrieve(key))
    109      .then((headers) => {
    110          assert_own_property(headers, 'sec-fetch-site');
    111          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
    112        });
    113  }, 'sec-fetch-site - Cross-Site -> Same Origin');
    114 
    115  promise_test(() => {
    116    const key = '{{uuid()}}';
    117    const url = makeRequestURL(
    118      key, ['httpsCrossSite', 'httpsSameSite'], { mime: 'application/javascript' }
    119    );
    120 
    121    return induceRequest(url)
    122      .then(() => retrieve(key))
    123      .then((headers) => {
    124          assert_own_property(headers, 'sec-fetch-site');
    125          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
    126        });
    127  }, 'sec-fetch-site - Cross-Site -> Same-Site');
    128 
    129  promise_test(() => {
    130    const key = '{{uuid()}}';
    131    const url = makeRequestURL(
    132      key, ['httpsCrossSite', 'httpsCrossSite'], { mime: 'application/javascript' }
    133    );
    134 
    135    return induceRequest(url)
    136      .then(() => retrieve(key))
    137      .then((headers) => {
    138          assert_own_property(headers, 'sec-fetch-site');
    139          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
    140        });
    141  }, 'sec-fetch-site - Cross-Site -> Cross-Site');
    142 
    143  promise_test(() => {
    144    const key = '{{uuid()}}';
    145    const url = makeRequestURL(
    146      key, ['httpsOrigin', 'httpsOrigin'], { mime: 'application/javascript' }
    147    );
    148 
    149    return induceRequest(url)
    150      .then(() => retrieve(key))
    151      .then((headers) => {
    152          assert_own_property(headers, 'sec-fetch-site');
    153          assert_array_equals(headers['sec-fetch-site'], ['same-origin']);
    154        });
    155  }, 'sec-fetch-site - Same-Origin -> Same Origin');
    156 
    157  promise_test(() => {
    158    const key = '{{uuid()}}';
    159    const url = makeRequestURL(
    160      key, ['httpsOrigin', 'httpsSameSite'], { mime: 'application/javascript' }
    161    );
    162 
    163    return induceRequest(url)
    164      .then(() => retrieve(key))
    165      .then((headers) => {
    166          assert_own_property(headers, 'sec-fetch-site');
    167          assert_array_equals(headers['sec-fetch-site'], ['same-site']);
    168        });
    169  }, 'sec-fetch-site - Same-Origin -> Same-Site');
    170 
    171  promise_test(() => {
    172    const key = '{{uuid()}}';
    173    const url = makeRequestURL(
    174      key, ['httpsOrigin', 'httpsCrossSite'], { mime: 'application/javascript' }
    175    );
    176 
    177    return induceRequest(url)
    178      .then(() => retrieve(key))
    179      .then((headers) => {
    180          assert_own_property(headers, 'sec-fetch-site');
    181          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
    182        });
    183  }, 'sec-fetch-site - Same-Origin -> Cross-Site');
    184 
    185  promise_test(() => {
    186    const key = '{{uuid()}}';
    187    const url = makeRequestURL(
    188      key, ['httpsSameSite', 'httpsOrigin'], { mime: 'application/javascript' }
    189    );
    190 
    191    return induceRequest(url)
    192      .then(() => retrieve(key))
    193      .then((headers) => {
    194          assert_own_property(headers, 'sec-fetch-site');
    195          assert_array_equals(headers['sec-fetch-site'], ['same-site']);
    196        });
    197  }, 'sec-fetch-site - Same-Site -> Same Origin');
    198 
    199  promise_test(() => {
    200    const key = '{{uuid()}}';
    201    const url = makeRequestURL(
    202      key, ['httpsSameSite', 'httpsSameSite'], { mime: 'application/javascript' }
    203    );
    204 
    205    return induceRequest(url)
    206      .then(() => retrieve(key))
    207      .then((headers) => {
    208          assert_own_property(headers, 'sec-fetch-site');
    209          assert_array_equals(headers['sec-fetch-site'], ['same-site']);
    210        });
    211  }, 'sec-fetch-site - Same-Site -> Same-Site');
    212 
    213  promise_test(() => {
    214    const key = '{{uuid()}}';
    215    const url = makeRequestURL(
    216      key, ['httpsSameSite', 'httpsCrossSite'], { mime: 'application/javascript' }
    217    );
    218 
    219    return induceRequest(url)
    220      .then(() => retrieve(key))
    221      .then((headers) => {
    222          assert_own_property(headers, 'sec-fetch-site');
    223          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
    224        });
    225  }, 'sec-fetch-site - Same-Site -> Cross-Site');
    226 
    227  promise_test(() => {
    228    const key = '{{uuid()}}';
    229    const url = makeRequestURL(
    230      key, [], { mime: 'application/javascript' }
    231    );
    232 
    233    return induceRequest(url)
    234      .then(() => retrieve(key))
    235      .then((headers) => {
    236          assert_own_property(headers, 'sec-fetch-mode');
    237          assert_array_equals(headers['sec-fetch-mode'], ['no-cors']);
    238        });
    239  }, 'sec-fetch-mode');
    240 
    241  promise_test(() => {
    242    const key = '{{uuid()}}';
    243    const url = makeRequestURL(
    244      key, [], { mime: 'application/javascript' }
    245    );
    246 
    247    return induceRequest(url)
    248      .then(() => retrieve(key))
    249      .then((headers) => {
    250          assert_own_property(headers, 'sec-fetch-dest');
    251          assert_array_equals(headers['sec-fetch-dest'], ['script']);
    252        });
    253  }, 'sec-fetch-dest');
    254 
    255  promise_test(() => {
    256    const key = '{{uuid()}}';
    257    const url = makeRequestURL(
    258      key, [], { mime: 'application/javascript' }
    259    );
    260 
    261    return induceRequest(url)
    262      .then(() => retrieve(key))
    263      .then((headers) => {
    264          assert_not_own_property(headers, 'sec-fetch-user');
    265        });
    266  }, 'sec-fetch-user');
    267 
    268  promise_test(() => {
    269    const key = '{{uuid()}}';
    270    const url = makeRequestURL(
    271      key, ['httpsCrossSite'], { mime: 'application/javascript' }
    272    );
    273 
    274    return induceRequest(url)
    275      .then(() => retrieve(key))
    276      .then((headers) => {
    277          assert_own_property(headers, 'sec-fetch-storage-access');
    278          assert_array_equals(headers['sec-fetch-storage-access'], ['none']);
    279        });
    280  }, 'sec-fetch-storage-access - Cross-site');
    281 
    282  promise_test(() => {
    283    const key = '{{uuid()}}';
    284    const url = makeRequestURL(
    285      key, ['httpsSameSite'], { mime: 'application/javascript' }
    286    );
    287 
    288    return induceRequest(url)
    289      .then(() => retrieve(key))
    290      .then((headers) => {
    291          assert_not_own_property(headers, 'sec-fetch-storage-access');
    292        });
    293  }, 'sec-fetch-storage-access - Same site');
    294  </script>
    295 </html>