tor-browser

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

element-video.https.sub.html (10499B)


      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/element-video.sub.html
      7 -->
      8 <html lang="en">
      9  <meta charset="utf-8">
     10  <title>HTTP headers on request for HTML "video" element source</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  <body>
     15  <script>
     16  'use strict';
     17 
     18  function induceRequest(url, attributes) {
     19    const video = document.createElement('video');
     20 
     21    for (const [ name, value ] of Object.entries(attributes)) {
     22      video.setAttribute(name, value);
     23    }
     24 
     25    return new Promise((resolve) => {
     26        video.setAttribute('src', url);
     27        video.onload = video.onerror = resolve;
     28      });
     29  }
     30 
     31  promise_test(() => {
     32    const key = '{{uuid()}}';
     33 
     34    return induceRequest(
     35        makeRequestURL(key, ['httpsOrigin']),
     36        {}
     37      )
     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, no attributes');
     44 
     45  promise_test(() => {
     46    const key = '{{uuid()}}';
     47 
     48    return induceRequest(
     49        makeRequestURL(key, ['httpsCrossSite']),
     50        {}
     51      )
     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, no attributes');
     58 
     59  promise_test(() => {
     60    const key = '{{uuid()}}';
     61 
     62    return induceRequest(
     63        makeRequestURL(key, ['httpsSameSite']),
     64        {}
     65      )
     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, no attributes');
     72 
     73  promise_test(() => {
     74    const key = '{{uuid()}}';
     75 
     76    return induceRequest(
     77        makeRequestURL(key, ['httpsOrigin', 'httpsCrossSite', 'httpsOrigin']),
     78        {}
     79      )
     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, no attributes');
     86 
     87  promise_test(() => {
     88    const key = '{{uuid()}}';
     89 
     90    return induceRequest(
     91        makeRequestURL(key, ['httpsOrigin', 'httpsSameSite', 'httpsOrigin']),
     92        {}
     93      )
     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, no attributes');
    100 
    101  promise_test(() => {
    102    const key = '{{uuid()}}';
    103 
    104    return induceRequest(
    105        makeRequestURL(key, ['httpsCrossSite', 'httpsOrigin']),
    106        {}
    107      )
    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, no attributes');
    114 
    115  promise_test(() => {
    116    const key = '{{uuid()}}';
    117 
    118    return induceRequest(
    119        makeRequestURL(key, ['httpsCrossSite', 'httpsSameSite']),
    120        {}
    121      )
    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, no attributes');
    128 
    129  promise_test(() => {
    130    const key = '{{uuid()}}';
    131 
    132    return induceRequest(
    133        makeRequestURL(key, ['httpsCrossSite', 'httpsCrossSite']),
    134        {}
    135      )
    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, no attributes');
    142 
    143  promise_test(() => {
    144    const key = '{{uuid()}}';
    145 
    146    return induceRequest(
    147        makeRequestURL(key, ['httpsOrigin', 'httpsOrigin']),
    148        {}
    149      )
    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, no attributes');
    156 
    157  promise_test(() => {
    158    const key = '{{uuid()}}';
    159 
    160    return induceRequest(
    161        makeRequestURL(key, ['httpsOrigin', 'httpsSameSite']),
    162        {}
    163      )
    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, no attributes');
    170 
    171  promise_test(() => {
    172    const key = '{{uuid()}}';
    173 
    174    return induceRequest(
    175        makeRequestURL(key, ['httpsOrigin', 'httpsCrossSite']),
    176        {}
    177      )
    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, no attributes');
    184 
    185  promise_test(() => {
    186    const key = '{{uuid()}}';
    187 
    188    return induceRequest(
    189        makeRequestURL(key, ['httpsSameSite', 'httpsOrigin']),
    190        {}
    191      )
    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, no attributes');
    198 
    199  promise_test(() => {
    200    const key = '{{uuid()}}';
    201 
    202    return induceRequest(
    203        makeRequestURL(key, ['httpsSameSite', 'httpsSameSite']),
    204        {}
    205      )
    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, no attributes');
    212 
    213  promise_test(() => {
    214    const key = '{{uuid()}}';
    215 
    216    return induceRequest(
    217        makeRequestURL(key, ['httpsSameSite', 'httpsCrossSite']),
    218        {}
    219      )
    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, no attributes');
    226 
    227  promise_test(() => {
    228    const key = '{{uuid()}}';
    229 
    230    return induceRequest(
    231        makeRequestURL(key, ['httpsOrigin', 'httpOrigin', 'httpsOrigin']),
    232        {}
    233      )
    234      .then(() => retrieve(key))
    235      .then((headers) => {
    236          assert_own_property(headers, 'sec-fetch-site');
    237          assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
    238        });
    239  }, 'sec-fetch-site - HTTPS downgrade-upgrade, no attributes');
    240 
    241  promise_test(() => {
    242    const key = '{{uuid()}}';
    243 
    244    return induceRequest(
    245        makeRequestURL(key, []),
    246        {}
    247      )
    248      .then(() => retrieve(key))
    249      .then((headers) => {
    250          assert_own_property(headers, 'sec-fetch-mode');
    251          assert_array_equals(headers['sec-fetch-mode'], ['no-cors']);
    252        });
    253  }, 'sec-fetch-mode - no attributes');
    254 
    255  promise_test(() => {
    256    const key = '{{uuid()}}';
    257 
    258    return induceRequest(
    259        makeRequestURL(key, []),
    260        {"crossorigin": ""}
    261      )
    262      .then(() => retrieve(key))
    263      .then((headers) => {
    264          assert_own_property(headers, 'sec-fetch-mode');
    265          assert_array_equals(headers['sec-fetch-mode'], ['cors']);
    266        });
    267  }, 'sec-fetch-mode - attributes: crossorigin');
    268 
    269  promise_test(() => {
    270    const key = '{{uuid()}}';
    271 
    272    return induceRequest(
    273        makeRequestURL(key, []),
    274        {"crossorigin": "anonymous"}
    275      )
    276      .then(() => retrieve(key))
    277      .then((headers) => {
    278          assert_own_property(headers, 'sec-fetch-mode');
    279          assert_array_equals(headers['sec-fetch-mode'], ['cors']);
    280        });
    281  }, 'sec-fetch-mode - attributes: crossorigin=anonymous');
    282 
    283  promise_test(() => {
    284    const key = '{{uuid()}}';
    285 
    286    return induceRequest(
    287        makeRequestURL(key, []),
    288        {"crossorigin": "use-credentials"}
    289      )
    290      .then(() => retrieve(key))
    291      .then((headers) => {
    292          assert_own_property(headers, 'sec-fetch-mode');
    293          assert_array_equals(headers['sec-fetch-mode'], ['cors']);
    294        });
    295  }, 'sec-fetch-mode - attributes: crossorigin=use-credentials');
    296 
    297  promise_test(() => {
    298    const key = '{{uuid()}}';
    299 
    300    return induceRequest(
    301        makeRequestURL(key, []),
    302        {}
    303      )
    304      .then(() => retrieve(key))
    305      .then((headers) => {
    306          assert_own_property(headers, 'sec-fetch-dest');
    307          assert_array_equals(headers['sec-fetch-dest'], ['video']);
    308        });
    309  }, 'sec-fetch-dest - no attributes');
    310 
    311  promise_test(() => {
    312    const key = '{{uuid()}}';
    313 
    314    return induceRequest(
    315        makeRequestURL(key, []),
    316        {}
    317      )
    318      .then(() => retrieve(key))
    319      .then((headers) => {
    320          assert_not_own_property(headers, 'sec-fetch-user');
    321        });
    322  }, 'sec-fetch-user - no attributes');
    323 
    324  promise_test(() => {
    325    const key = '{{uuid()}}';
    326 
    327    return induceRequest(
    328        makeRequestURL(key, ['httpsCrossSite']),
    329        {}
    330      )
    331      .then(() => retrieve(key))
    332      .then((headers) => {
    333          assert_own_property(headers, 'sec-fetch-storage-access');
    334          assert_array_equals(headers['sec-fetch-storage-access'], ['none']);
    335        });
    336  }, 'sec-fetch-storage-access - Cross-site, no attributes');
    337 
    338  promise_test(() => {
    339    const key = '{{uuid()}}';
    340 
    341    return induceRequest(
    342        makeRequestURL(key, ['httpsSameSite']),
    343        {}
    344      )
    345      .then(() => retrieve(key))
    346      .then((headers) => {
    347          assert_not_own_property(headers, 'sec-fetch-storage-access');
    348        });
    349  }, 'sec-fetch-storage-access - Same site, no attributes');
    350  </script>
    351  </body>
    352 </html>