third_party/WebKit/LayoutTests/http/tests/fetch/script-tests/request.js

   1 if (self.importScripts) {
   2   importScripts('../resources/fetch-test-helpers.js');
   3 }
   4
   5 var URL = 'https://www.example.com/test.html';
   6
   7 test(function() {
   8     var headers = new Headers;
   9     headers.set('User-Agent', 'Mozilla/5.0');
  10     headers.set('Accept', 'text/html');
  11     headers.set('X-Fetch-Test', 'request test field');
  12
  13     var request = new Request(URL, {method: 'GET', headers: headers});
  14
  15     assert_equals(request.url, URL, 'Request.url should match');
  16     assert_equals(request.method, 'GET', 'Request.method should match');
  17     assert_equals(request.referrer, 'about:client',
  18                   'Request.referrer should be about:client');
  19     assert_true(request.headers instanceof Headers,
  20                 'Request.headers should be Headers');
  21
  22     // 'User-Agent' is a forbidden header.
  23     assert_equals(size(request.headers), 2,
  24                   'Request.headers size should match');
  25     // Note: detailed behavioral tests for Headers are in another test,
  26     // http/tests/fetch/*/headers.html.
  27
  28     request.url = 'http://localhost/';
  29     assert_equals(request.url, 'https://www.example.com/test.html',
  30                   'Request.url should be readonly');
  31
  32     // Unmatched lead surrogate.
  33     request = new Request('http://localhost/\uD800');
  34     assert_equals(request.url,
  35                   'http://localhost/' + encodeURIComponent('\uFFFD'),
  36                   'Request.url should have unmatched surrogates replaced.');
  37
  38     request.method = 'POST';
  39     assert_equals(request.method, 'GET', 'Request.method should be readonly');
  40   }, 'Request basic test');
  41
  42 test(function() {
  43     [new Request(URL),
  44      // All mode/credentials below are invalid and thus ignored.
  45      new Request(URL, {mode: null}),
  46      new Request(URL, {mode: undefined}),
  47      new Request(URL, {mode: 'sameorigin'}),
  48      new Request(URL, {mode: 'same origin'}),
  49      new Request(URL, {mode: 'same-origin\0'}),
  50      new Request(URL, {mode: ' same-origin'}),
  51      new Request(URL, {mode: 'same--origin'}),
  52      new Request(URL, {mode: 'SAME-ORIGIN'}),
  53      new Request(URL, {mode: 'nocors'}),
  54      new Request(URL, {mode: 'no cors'}),
  55      new Request(URL, {mode: 'no-cors\0'}),
  56      new Request(URL, {mode: ' no-cors'}),
  57      new Request(URL, {mode: 'no--cors'}),
  58      new Request(URL, {mode: 'NO-CORS'}),
  59      new Request(URL, {mode: 'cors\0'}),
  60      new Request(URL, {mode: ' cors'}),
  61      new Request(URL, {mode: 'co rs'}),
  62      new Request(URL, {mode: 'CORS'}),
  63      new Request(URL, {mode: '\0'.repeat(100000)}),
  64      new Request(URL, {mode: 'x'.repeat(100000)}),
  65      new Request(URL, {credentials: null}),
  66      new Request(URL, {credentials: undefined}),
  67      new Request(URL, {credentials: 'omit\0'}),
  68      new Request(URL, {credentials: ' omit'}),
  69      new Request(URL, {credentials: 'om it'}),
  70      new Request(URL, {credentials: 'OMIT'}),
  71      new Request(URL, {credentials: 'sameorigin'}),
  72      new Request(URL, {credentials: 'same origin'}),
  73      new Request(URL, {credentials: 'same-origin\0'}),
  74      new Request(URL, {credentials: ' same-origin'}),
  75      new Request(URL, {credentials: 'same--origin'}),
  76      new Request(URL, {credentials: 'SAME-ORIGIN'}),
  77      new Request(URL, {credentials: 'include\0'}),
  78      new Request(URL, {credentials: ' include'}),
  79      new Request(URL, {credentials: 'inc lude'}),
  80      new Request(URL, {credentials: 'INCLUDE'}),
  81      new Request(URL, {credentials: '\0'.repeat(100000)}),
  82      new Request(URL, {credentials: 'x'.repeat(100000)})]
  83       .concat(INVALID_TOKENS.map(
  84           function(name) { return new Request(URL, {mode: name}); }))
  85       .concat(INVALID_TOKENS.map(
  86           function(name) { return new Request(URL, {credentials: name}); }))
  87       .forEach(function(request) {
  88           assert_equals(request.url, URL,
  89                         'Request.url should match');
  90           assert_equals(request.method, 'GET',
  91                         'Default Request.method should be GET');
  92           assert_equals(request.mode, 'cors',
  93                         'Default Request.mode should be cors');
  94           assert_equals(request.credentials, 'omit',
  95                         'Default Request.credentials should be omit');
  96         });
  97   }, 'Request default value test');
  98
  99 test(function() {
 100     var request = new Request(URL);
 101     request.headers.append('X-Fetch-Foo', 'foo1');
 102     request.headers.append('X-Fetch-Foo', 'foo2');
 103     request.headers.append('X-Fetch-Bar', 'bar');
 104     var request2 = new Request(request);
 105     assert_equals(request2.url, URL, 'Request.url should match');
 106     assert_equals(request2.method, 'GET', 'Request.method should match');
 107     assert_equals(request2.mode, 'cors', 'Request.mode should match');
 108     assert_equals(request2.credentials, 'omit',
 109                   'Request.credentials should match');
 110     assert_equals(request2.headers.getAll('X-Fetch-Foo')[0], 'foo1',
 111                   'Request.headers should match');
 112     assert_equals(request2.headers.getAll('X-Fetch-Foo')[1], 'foo2',
 113                   'Request.headers should match');
 114     assert_equals(request2.headers.getAll('X-Fetch-Bar')[0], 'bar',
 115                   'Request.headers should match');
 116     var request3 = new Request(URL,
 117                                {headers: [['X-Fetch-Foo', 'foo1'],
 118                                           ['X-Fetch-Foo', 'foo2'],
 119                                           ['X-Fetch-Bar', 'bar']]});
 120     assert_equals(request3.headers.getAll('X-Fetch-Foo')[0], 'foo1',
 121                   'Request.headers should match');
 122     assert_equals(request3.headers.getAll('X-Fetch-Foo')[1], 'foo2',
 123                   'Request.headers should match');
 124     assert_equals(request3.headers.getAll('X-Fetch-Bar')[0], 'bar',
 125                   'Request.headers should match');
 126   }, 'Request header test');
 127
 128 test(function() {
 129     var request1 = {};
 130     var request2 = {};
 131     var METHODS = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS',
 132                    undefined];
 133     var MODES = ['same-origin', 'no-cors', 'cors', '', undefined];
 134     function isSimpleMethod(method) {
 135       return ['GET', 'HEAD', 'POST', undefined].indexOf(method) != -1;
 136     };
 137     function effectiveMethod(method1, method2) {
 138       return method2 ? method2 : (method1 ? method1 : 'GET');
 139     };
 140     function effectiveMode(mode1, mode2) {
 141       return mode2 ? mode2 : (mode1 ? mode1 : 'cors');
 142     };
 143     METHODS.forEach(function(method1) {
 144         MODES.forEach(function(mode1) {
 145             var init1 = {};
 146             if (method1 != undefined) { init1['method'] = method1; }
 147             if (mode1 != undefined) { init1['mode'] = mode1; }
 148             if (!isSimpleMethod(method1) && mode1 == 'no-cors') {
 149               assert_throws(
 150                 {name: 'TypeError'},
 151                 function() { request1 = new Request(URL, init1); },
 152                 'new no-cors Request with non simple method (' + method1 +
 153                 ') should throw');
 154               return;
 155             }
 156             request1 = new Request(URL, init1);
 157             assert_equals(request1.method, method1 ? method1 : 'GET',
 158                           'Request.method should match');
 159             assert_equals(request1.mode, mode1 ? mode1 : 'cors',
 160                           'Request.mode should match');
 161             request1 = new Request(request1);
 162             assert_equals(request1.method, method1 ? method1 : 'GET',
 163                           'Request.method should match');
 164             assert_equals(request1.mode, mode1 ? mode1 : 'cors',
 165                           'Request.mode should match');
 166             METHODS.forEach(function(method2) {
 167                 MODES.forEach(function(mode2) {
 168                     // We need to construct a new request1 because as soon as it
 169                     // is used in a constructor it will be flagged as 'used',
 170                     // and we can no longer construct objects with it.
 171                     request1 = new Request(URL, init1);
 172                     var init2 = {};
 173                     if (method2 != undefined) { init2['method'] = method2; }
 174                     if (mode2 != undefined) { init2['mode'] = mode2; }
 175                     if (!isSimpleMethod(effectiveMethod(method1, method2)) &&
 176                         effectiveMode(mode1, mode2) == 'no-cors') {
 177                       assert_throws(
 178                         {name: 'TypeError'},
 179                         function() { request2 = new Request(request1, init2); },
 180                         'new no-cors Request with non simple method should ' +
 181                         'throw');
 182                       return;
 183                     }
 184                     request2 = new Request(request1, init2);
 185                     assert_equals(request2.method,
 186                                   method2 ? method2 : request1.method,
 187                                   'Request.method should be overridden');
 188                     assert_equals(request2.mode,
 189                                   mode2 ? mode2 : request1.mode,
 190                                   'Request.mode should be overridden');
 191                   });
 192               });
 193           });
 194       });
 195   }, 'Request header test');
 196
 197 test(function() {
 198     var request1 = {};
 199     var request2 = {};
 200     var CREDENTIALS = ['omit', 'same-origin', 'include', '', undefined];
 201     CREDENTIALS.forEach(function(credentials1) {
 202         var init1 = {};
 203         if (credentials1 != undefined) { init1['credentials'] = credentials1; }
 204         request1 = new Request(URL, init1);
 205         assert_equals(request1.credentials, credentials1 || 'omit',
 206                       'Request.credentials should match');
 207         request1 = new Request(request1);
 208         assert_equals(request1.credentials, credentials1 || 'omit',
 209                       'Request.credentials should match');
 210         CREDENTIALS.forEach(function(credentials2) {
 211             request1 = new Request(URL, init1);
 212             var init2 = {};
 213             if (credentials2 != undefined) {
 214               init2['credentials'] = credentials2;
 215             }
 216             request2 = new Request(request1, init2);
 217             assert_equals(request2.credentials,
 218                           credentials2 ? credentials2 : request1.credentials,
 219                           'Request.credentials should be overridden');
 220           });
 221       });
 222   }, 'Request credentials test');
 223
 224 test(function() {
 225     var request1 = {};
 226     var request2 = {};
 227     var REDIRECTS = ['follow', 'error', 'manual', '', undefined];
 228     REDIRECTS.forEach(function(redirect1) {
 229         var init1 = {};
 230         if (redirect1 != undefined) { init1['redirect'] = redirect1; }
 231         request1 = new Request(URL, init1);
 232         assert_equals(request1.redirect, redirect1 || 'follow',
 233                       'Request.redirect should match');
 234         request1 = new Request(request1);
 235         assert_equals(request1.redirect, redirect1 || 'follow',
 236                       'Request.redirect should match');
 237         REDIRECTS.forEach(function(redirect2) {
 238             request1 = new Request(URL, init1);
 239             var init2 = {};
 240             if (redirect2 != undefined) {
 241               init2['redirect'] = redirect2;
 242             }
 243             request2 = new Request(request1, init2);
 244             assert_equals(request2.redirect,
 245                           redirect2 ? redirect2 : request1.redirect,
 246                           'Request.redirect should be overridden');
 247           });
 248       });
 249   }, 'Request redirect test');
 250
 251 test(function() {
 252     var request1 = {};
 253     var request2 = {};
 254     var init = {};
 255     request1 = new Request(URL, init);
 256     assert_equals(request1.integrity, '',
 257                   'Request.integrity should be empty on init');
 258     init['integrity'] = 'sha256-deadbeef';
 259     request1 = new Request(URL, init);
 260     assert_equals(request1.integrity, 'sha256-deadbeef',
 261                   'Request.integrity match the integrity of init');
 262     request2 = new Request(request1);
 263     assert_equals(request2.integrity, 'sha256-deadbeef',
 264                   'Request.integrity should match');
 265     init['mode'] = 'no-cors';
 266     assert_throws(
 267         {name: 'TypeError'},
 268         function() {
 269             var request = new Request(URL, init);
 270         },
 271         'new Request with a non-empty integrity and mode of \'no-cors\' should throw');
 272 }, 'Request integrity test');
 273
 274 test(function() {
 275     ['same-origin', 'cors', 'no-cors'].forEach(function(mode) {
 276         FORBIDDEN_METHODS.forEach(function(method) {
 277             assert_throws(
 278               {name: 'TypeError'},
 279               function() {
 280                 var request = new Request(URL, {mode: mode, method: method});
 281               },
 282               'new Request with a forbidden method (' + method + ') should ' +
 283               'throw');
 284           });
 285         INVALID_METHOD_NAMES.forEach(function(name) {
 286             assert_throws(
 287               {name: 'TypeError'},
 288               function() {
 289                 var request = new Request(URL, {mode: mode, method: name});
 290               },
 291               'new Request with an invalid method (' + name + ') should throw');
 292           });
 293       });
 294   }, 'Request method name throw test');
 295
 296 test(function() {
 297     var url = 'http://example.com';
 298     TO_BE_NORMALIZED_METHOD_NAMES.forEach(
 299       function(method) {
 300         assert_equals(new Request(url, {method: method.toUpperCase()}).method,
 301                       method.toUpperCase(),
 302                       'method must match: ' + method);
 303         assert_equals(new Request(url, {method: method}).method,
 304                       method.toUpperCase(),
 305                       'method should be normalized to uppercase: ' + method);
 306       });
 307
 308     OTHER_VALID_METHOD_NAMES.forEach(
 309       function(method) {
 310         assert_equals(new Request(url, {method: method}).method, method,
 311                       'method should not be changed when normalized: ' +
 312                       method);
 313         method = method.toLowerCase();
 314         assert_equals(new Request(url, {method: method}).method, method,
 315                       'method should not be changed when normalized: ' +
 316                       method);
 317       });
 318   }, 'Request: valid method names and normalize test');
 319
 320 test(function() {
 321     var req = new Request(URL);
 322     assert_false(req.bodyUsed,
 323                  'Request should not be flagged as used if it has not been ' +
 324                  'consumed.');
 325     // See https://crbug.com/501195.
 326     var req2 = new Request(req);
 327     assert_true(req.bodyUsed,
 328                 'Request should be flagged as used if it does not have' +
 329                 'body.');
 330     assert_false(req2.bodyUsed,
 331                  'Request should not be flagged as used if it has not been ' +
 332                  'consumed.');
 333   }, 'Request construction without body behavior regardning "bodyUsed"');
 334
 335 test(function() {
 336     var req = new Request(URL, {method: 'POST', body: 'hello'});
 337     assert_false(req.bodyUsed,
 338                  'Request should not be flagged as used if it has not been ' +
 339                  'consumed.');
 340     var req2 = new Request(req);
 341     assert_true(req.bodyUsed,
 342                 'Request should be flagged as used if it has been consumed.');
 343     assert_false(req2.bodyUsed,
 344                  'Request should not be flagged as used if it has not been ' +
 345                  'consumed.');
 346     // See https://crbug.com/501195.
 347     assert_throws(
 348       {name: 'TypeError'},
 349       function() { new Request(req); },
 350       'Request construction should throw if used.');
 351   }, 'Request construction without body behavior regardning "bodyUsed"');
 352
 353 test(function() {
 354     var req = new Request(URL, {method: 'POST', body: 'hello'});
 355     assert_false(req.bodyUsed,
 356                  'Request should not be flagged as used if it has not been ' +
 357                  'consumed.');
 358     assert_throws(
 359       {name: 'TypeError'},
 360       function() { new Request(req, {method: 'GET'}); },
 361       'A get request may not have body.');
 362
 363     assert_false(req.bodyUsed, 'After the GET case');
 364
 365     assert_throws(
 366       {name: 'TypeError'},
 367       function() { new Request(req, {method: 'CONNECT'}); },
 368       'Request() with a forbidden method must throw.');
 369
 370     assert_false(req.bodyUsed, 'After the forbidden method case');
 371
 372     var req2 = new Request(req);
 373     assert_true(req.bodyUsed,
 374                 'Request should be flagged as used if it has been consumed.');
 375   }, 'Request construction failure should not set "bodyUsed"');
 376
 377 test(function() {
 378     assert_equals(new Request(URL).referrer, 'about:client');
 379   }, 'Request without RequestInit.');
 380
 381 test(function() {
 382     var req = new Request(URL, {referrer: 'about:client'});
 383
 384     assert_equals(req.referrer, 'about:client',
 385                   'constructed with referrer=about:client');
 386     assert_equals(new Request(req.clone()).referrer, 'about:client',
 387                  'cloned from a request with referrer=about:client');
 388     assert_equals(new Request(req.clone(), {foo: null}).referrer,
 389                   'about:client',
 390                   'constructed from a request with referrer=about:client');
 391     assert_equals(new Request(req.clone(), {method: 'GET'}).referrer,
 392                   'about:client',
 393                   'constructed with method from a request with ' +
 394                   'referrer=about:client');
 395   }, 'Request with referrer=about:client.');
 396
 397 test(function() {
 398     var req = new Request(URL, {referrer: ''});
 399
 400     assert_equals(req.referrer, '', 'constructed with no-referrer');
 401     assert_equals(new Request(req.clone()).referrer, '',
 402                   'cloned from a request with no-referrer');
 403     assert_equals(new Request(req.clone(), {foo: null}).referrer, '',
 404                   'constructed from a request with no-referrer');
 405     assert_equals(new Request(req.clone(), {method: 'GET'}).referrer,
 406                   'about:client',
 407                   'constructed with method from a request with no-referrer');
 408   }, 'Request with no-referrer.');
 409
 410 test(function() {
 411     var referrer = BASE_ORIGIN + '/path?query';
 412     var req = new Request(URL, {referrer: referrer});
 413
 414     assert_equals(req.referrer, referrer, 'constructed with a url referrer');
 415     assert_equals(req.clone().referrer, referrer,
 416                   'cloned from a request with a url referrer');
 417     assert_equals(new Request(req.clone(), {foo: null}).referrer, referrer,
 418                   'constructed from a request with a url referrer');
 419     assert_equals(new Request(req.clone(), {method: 'GET'}).referrer,
 420                   'about:client',
 421                   'constructed with method from a request with a url referrer');
 422   }, 'Request with a url referrer');
 423
 424 test(function() {
 425     var referrer =
 426         (BASE_ORIGIN + '/path/?query#hash').replace('//', '//user:pass@');
 427     var req = new Request(URL, {referrer: referrer});
 428     assert_equals(req.referrer, referrer, 'constructed with a url referrer');
 429   }, 'Request with a url referrer containing user, pass, and so on');
 430
 431 test(function() {
 432     var referrer = OTHER_ORIGIN + '/path?query';
 433     assert_throws({name: 'TypeError'},
 434         () => new Request(URL, {referrer: referrer}));
 435   }, 'Request with a url with another origin');
 436
 437 test(function() {
 438     var referrer = 'invali\0d';
 439     assert_throws({name: 'TypeError'},
 440         () => new Request(URL, {referrer: referrer}));
 441   }, 'Request with an invalid referrer');
 442
 443 test(function() {
 444     var referrer = '/path?query';
 445     var expected = BASE_ORIGIN + '/path?query';
 446
 447     assert_equals(new Request(URL, {referrer: referrer}).referrer, expected);
 448   }, 'Request with a relative referrer');
 449
 450 // Spec: https://fetch.spec.whatwg.org/#dom-request
 451 // Step 21:
 452 // If request's method is `GET` or `HEAD`, throw a TypeError.
 453 promise_test(function() {
 454     var headers = new Headers;
 455     headers.set('Content-Language', 'ja');
 456     ['GET', 'HEAD'].forEach(function(method) {
 457         assert_throws(
 458           {name: 'TypeError'},
 459           function() {
 460             new Request(URL,
 461                         {method: method,
 462                          body: new Blob(['Test Blob'], {type: 'test/type'})
 463                         });
 464           },
 465           'Request of GET/HEAD method cannot have RequestInit body.');
 466       });
 467   }, 'Request of GET/HEAD method cannot have RequestInit body.');
 468
 469 promise_test(function() {
 470     var headers = new Headers;
 471     headers.set('Content-Language', 'ja');
 472     var req = new Request(URL, {
 473         method: 'POST',
 474         headers: headers,
 475         body: new Blob(['Test Blob'], {type: 'test/type'})
 476       });
 477     var req2 = req.clone();
 478     // Change headers and of original request.
 479     req.headers.set('Content-Language', 'en');
 480     assert_equals(req2.headers.get('Content-Language'), 'ja',
 481                   'Headers of cloned request should not change when ' +
 482                   'original request headers are changed.');
 483
 484     return req.text().then(function(text) {
 485         assert_equals(text, 'Test Blob', 'Body of request should match.');
 486         return req2.text();
 487       }).then(function(text) {
 488         assert_equals(text, 'Test Blob', 'Cloned request body should match.');
 489         return Promise.all([req.text(), req2.text()]);
 490       }).then(function(texts) {
 491         assert_equals(texts[0], '', 'The body is consumed.');
 492         assert_equals(texts[1], '', 'The body is consumed.');
 493         return req.clone().text();
 494       }).then(function(text) {
 495         assert_equals(text, '', 'The body was consumed before cloned.');
 496       });
 497   }, 'Test clone behavior with loading content from Request.');
 498
 499 async_test(function(t) {
 500     var request =
 501       new Request(URL,
 502                   {
 503                     method: 'POST',
 504                     body: new Blob(['Test Blob'], {type: 'test/type'})
 505                   });
 506     assert_equals(
 507       getContentType(request.headers), 'test/type',
 508       'ContentType header of Request created with Blob body must be set.');
 509     assert_false(request.bodyUsed,
 510                  'bodyUsed must be true before calling text()');
 511     request.text()
 512       .then(function(result) {
 513           assert_equals(result, 'Test Blob',
 514                         'Creating a Request with Blob body should success.');
 515
 516           request = new Request(URL, {method: 'POST', body: 'Test String'});
 517           assert_equals(
 518             getContentType(request.headers), 'text/plain;charset=UTF-8',
 519             'ContentType header of Request created with string must be set.');
 520           return request.text();
 521         })
 522       .then(function(result) {
 523           assert_equals(result, 'Test String',
 524                         'Creating a Request with string body should success.');
 525
 526           var text = 'Test ArrayBuffer';
 527           var array = new Uint8Array(text.length);
 528           for (var i = 0; i < text.length; ++i)
 529             array[i] = text.charCodeAt(i);
 530           request = new Request(URL, {method: 'POST', body: array.buffer});
 531           return request.text();
 532         })
 533       .then(function(result) {
 534           assert_equals(
 535             result, 'Test ArrayBuffer',
 536             'Creating a Request with ArrayBuffer body should success.');
 537
 538           var text = 'Test ArrayBufferView';
 539           var array = new Uint8Array(text.length);
 540           for (var i = 0; i < text.length; ++i)
 541             array[i] = text.charCodeAt(i);
 542           request = new Request(URL, {method: 'POST', body: array});
 543           return request.text();
 544         })
 545       .then(function(result) {
 546           assert_equals(
 547             result, 'Test ArrayBufferView',
 548             'Creating a Request with ArrayBuffer body should success.');
 549
 550           var formData = new FormData();
 551           formData.append('sample string', '1234567890');
 552           formData.append('sample blob', new Blob(['blob content']));
 553           formData.append('sample file',
 554                           new File(['file content'], 'file.dat'));
 555           request = new Request(URL, {method: 'POST', body: formData});
 556           return request.text();
 557         })
 558       .then(function(result) {
 559           var reg = new RegExp('multipart\/form-data; boundary=(.*)');
 560           var regResult = reg.exec(getContentType(request.headers));
 561           var boundary = regResult[1];
 562           var expected_body =
 563             '--' + boundary + '\r\n' +
 564             'Content-Disposition: form-data; name="sample string"\r\n' +
 565             '\r\n' +
 566             '1234567890\r\n' +
 567             '--' + boundary + '\r\n' +
 568             'Content-Disposition: form-data; name="sample blob"; ' +
 569             'filename="blob"\r\n' +
 570             'Content-Type: application/octet-stream\r\n' +
 571             '\r\n' +
 572             'blob content\r\n' +
 573             '--' + boundary + '\r\n' +
 574             'Content-Disposition: form-data; name="sample file"; ' +
 575             'filename="file.dat"\r\n' +
 576             'Content-Type: application/octet-stream\r\n' +
 577             '\r\n' +
 578             'file content\r\n' +
 579             '--' + boundary + '--\r\n';
 580           assert_equals(
 581             result, expected_body,
 582             'Creating a Request with FormData body should success.');
 583         })
 584       .then(function() {
 585           t.done();
 586         })
 587       .catch(unreached_rejection(t));
 588     assert_true(request.bodyUsed,
 589                 'bodyUsed must be true after calling text()');
 590   }, 'Request body test');
 591
 592 test(function() {
 593     // https://fetch.spec.whatwg.org/#dom-request
 594     // Step 20:
 595     // Fill r's Headers object with headers. Rethrow any exceptions.
 596     INVALID_HEADER_NAMES.forEach(function(name) {
 597         assert_throws(
 598           {name: 'TypeError'},
 599           function() {
 600             var obj = {};
 601             obj[name] = 'a';
 602             new Request('http://localhost/', {headers: obj});
 603           },
 604           'new Request with headers with an invalid name (' + name +
 605           ') should throw');
 606         assert_throws(
 607           {name: 'TypeError'},
 608           function() {
 609             new Request('http://localhost/', {headers: [[name, 'a']]});
 610           },
 611           'new Request with headers with an invalid name (' + name +
 612           ') should throw');
 613       });
 614
 615     INVALID_HEADER_VALUES.forEach(function(value) {
 616         assert_throws(
 617           {name: 'TypeError'},
 618           function() {
 619             new Request('http://localhost/',
 620                          {headers: {'X-Fetch-Test': value}});
 621           },
 622           'new Request with headers with an invalid value should throw');
 623         assert_throws(
 624           {name: 'TypeError'},
 625           function() {
 626             new Request('http://localhost/',
 627                          {headers: [['X-Fetch-Test', value]]});
 628           },
 629           'new Request with headers with an invalid value should throw');
 630       });
 631   }, 'Request throw error test');
 632
 633 // Tests for MIME types.
 634 promise_test(function(t) {
 635     var req = new Request('http://localhost/',
 636                           {method: 'POST', body: new Blob([''])});
 637     return req.blob()
 638       .then(function(blob) {
 639           assert_equals(blob.type, '');
 640           assert_equals(req.headers.get('Content-Type'), null);
 641         });
 642   }, 'MIME type for Blob');
 643
 644 promise_test(function(t) {
 645     var req = new Request('http://localhost/',
 646                           {method: 'POST',
 647                            body: new Blob([''], {type: 'Text/Plain'})});
 648     return req.blob()
 649       .then(function(blob) {
 650           assert_equals(blob.type, 'text/plain');
 651           assert_equals(req.headers.get('Content-Type'), 'text/plain');
 652           return new Request(req).blob();
 653         }).then(function(blob) {
 654           assert_equals(blob.type, 'text/plain');
 655         });
 656   }, 'MIME type for Blob with non-empty type');
 657
 658 promise_test(function(t) {
 659     var req = new Request('http://localhost/',
 660                           {method: 'POST', body: new FormData()});
 661     return req.blob()
 662       .then(function(blob) {
 663           assert_equals(blob.type.indexOf('multipart/form-data; boundary='),
 664                         0);
 665           assert_equals(req.headers.get('Content-Type')
 666                           .indexOf('multipart/form-data; boundary='),
 667                         0);
 668         });
 669   }, 'MIME type for FormData');
 670
 671 promise_test(function(t) {
 672     var req = new Request('http://localhost/',
 673                           {method: 'POST', body: ''});
 674     return req.blob()
 675       .then(function(blob) {
 676           assert_equals(blob.type, 'text/plain;charset=utf-8');
 677           assert_equals(req.headers.get('Content-Type'),
 678                         'text/plain;charset=UTF-8');
 679         });
 680   }, 'MIME type for USVString');
 681
 682 promise_test(function(t) {
 683     var req = new Request('http://localhost/',
 684                           {method: 'POST',
 685                            body: new Blob([''], {type: 'Text/Plain'}),
 686                            headers: [['Content-Type', 'Text/Html']]});
 687     var clone = req.clone();
 688     return Promise.all([req.blob(), clone.blob()])
 689       .then(function(blobs) {
 690           assert_equals(blobs[0].type, 'text/html');
 691           assert_equals(blobs[1].type, 'text/html');
 692           assert_equals(req.headers.get('Content-Type'), 'Text/Html');
 693           assert_equals(clone.headers.get('Content-Type'), 'Text/Html');
 694         });
 695   }, 'Extract a MIME type with clone');
 696
 697 promise_test(function(t) {
 698     var req = new Request('http://localhost/',
 699                           {method: 'POST',
 700                            body: new Blob([''], {type: 'Text/Plain'})});
 701     req.headers.set('Content-Type', 'Text/Html');
 702     return req.blob()
 703       .then(function(blob) {
 704           assert_equals(blob.type, 'text/plain');
 705           assert_equals(req.headers.get('Content-Type'), 'Text/Html');
 706         });
 707   },
 708   'MIME type unchanged if headers are modified after Request() constructor');
 709
 710 promise_test(function(t) {
 711     var req = new Request('http://localhost/',
 712                           {method: 'POST',
 713                            body: new Blob([''], {type: 'Text/Plain'}),
 714                            headers: [['Content-Type', 'Text/Html']]});
 715     return req.blob()
 716       .then(function(blob) {
 717           assert_equals(blob.type, 'text/html');
 718           assert_equals(req.headers.get('Content-Type'), 'Text/Html');
 719         });
 720   }, 'Extract a MIME type (1)');
 721
 722 promise_test(function(t) {
 723     var req = new Request('http://localhost/', {method: 'POST', body: 'hello'});
 724     return req.text().then(function(text) {
 725         assert_equals(text, 'hello');
 726         var req2 = new Request(req);
 727         assert_true(req.bodyUsed);
 728         assert_false(req2.bodyUsed);
 729         return req2.text();
 730       }).then(function(text) {
 731         assert_equals(text, '');
 732       });
 733   }, 'Consume and pass');
 734
 735 done();