fetch redirect is incompatible with "no-cors" mode
[WebKit-https.git] / LayoutTests / imported / w3c / web-platform-tests / service-workers / service-worker / fetch-event-redirect.https.html
1 <!DOCTYPE html>
2 <title>Service Worker: Fetch Event Redirect Handling</title>
3 <meta name=timeout content=long>
4 <script src="/resources/testharness.js"></script>
5 <script src="resources/testharness-helpers.js"></script>
6 <script src="/resources/testharnessreport.js"></script>
7 <script src="/common/get-host-info.sub.js"></script>
8 <script src="resources/test-helpers.sub.js"></script>
9 <body>
10 <script>
11
12 // ------------------------
13 // Utilities for testing non-navigation requests that are intercepted with
14 // a redirect.
15
16 const host_info = get_host_info();
17 const kScript = 'resources/fetch-rewrite-worker.js';
18 const kScope = host_info['HTTPS_ORIGIN'] + base_path() +
19                'resources/blank.html?fetch-event-redirect';
20 let frame;
21
22 function redirect_fetch_test(t, test) {
23   const hostKeySuffix = test['url_credentials'] ? '_WITH_CREDS' : '';
24   const successPath = base_path() + 'resources/success.py';
25
26   let acaOrigin = '';
27   let host = host_info['HTTPS_ORIGIN' + hostKeySuffix];
28   if (test['redirect_dest'] === 'no-cors') {
29     host = host_info['HTTPS_REMOTE_ORIGIN' + hostKeySuffix]
30   } else if (test['redirect_dest'] === 'cors') {
31     acaOrigin = '?ACAOrigin=' + encodeURIComponent(host_info['HTTPS_ORIGIN']);
32     host = host_info['HTTPS_REMOTE_ORIGIN' + hostKeySuffix]
33   }
34
35   const dest = '?Redirect=' + encodeURIComponent(host + successPath + acaOrigin);
36   const expectedTypeParam =
37       test['expected_type']
38           ? '&expected_type=' + test['expected_type']
39           : '';
40   const expectedRedirectedParam =
41       test['expected_redirected']
42           ? '&expected_redirected=' + test['expected_redirected']
43           : '';
44   const url = '/' + test.name +
45             '?url=' + encodeURIComponent('redirect.py' + dest) +
46             expectedTypeParam + expectedRedirectedParam
47   const request = new Request(url, test.request_init);
48
49   if (test.should_reject) {
50     return assert_promise_rejects(
51       frame.contentWindow.fetch(request),
52       new TypeError(),
53       'Must fail to fetch: url=' + url);
54   }
55   return frame.contentWindow.fetch(request).then((response) => {
56       assert_equals(response.type, test.expected_type,
57                     'response.type');
58       assert_equals(response.redirected, test.expected_redirected,
59                     'response.redirected');
60       if (response.type === 'opaque' || response.type === 'opaqueredirect') {
61         return;
62       }
63       return response.json().then((json) => {
64         assert_equals(json.result, 'success', 'JSON result must be "success".');
65       });
66     });
67 }
68
69 // Set up the service worker and the frame.
70 promise_test(t => {
71     return service_worker_unregister_and_register(t, kScript, kScope)
72       .then(registration => {
73           promise_test(() => {
74               return registration.unregister();
75             }, 'restore global state');
76
77           return wait_for_state(t, registration.installing, 'activated');
78         })
79       .then(() => {
80           return with_iframe(kScope);
81         })
82       .then(f => {
83           frame = f;
84           add_completion_callback(() => { f.remove(); });
85         });
86   }, 'initialize global state');
87
88 // ------------------------
89 // Test every combination of:
90 //  - RequestMode (same-origin, cors, no-cors)
91 //  - RequestRedirect (manual, follow, error)
92 //  - redirect destination origin (same-origin, cors, no-cors)
93 //  - redirect destination credentials (no user/pass, user/pass)
94 //
95 // TODO: add navigation requests
96 // TODO: add redirects to data URI and verify same-origin data-URL flag behavior
97 // TODO: add test where original redirect URI is cross-origin
98 // TODO: verify final method is correct for 301, 302, and 303
99 // TODO: verify CORS redirect results in all further redirects being
100 //       considered cross origin
101
102 promise_test(function(t) {
103   return redirect_fetch_test(t, {
104     name: 'nonav-manual-cors-redirects-to-sameorigin-nocreds',
105     redirect_dest: 'same-origin',
106     url_credentials: false,
107     expected_type: 'opaqueredirect',
108     expected_redirected: false,
109     request_init: {
110       redirect: 'manual',
111       mode: 'cors'
112     },
113     should_reject: false
114   });
115 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
116    'same-origin without credentials should succeed opaqueredirect ' +
117    'interception and response should not be redirected');
118
119 promise_test(function(t) {
120   return redirect_fetch_test(t, {
121     name: 'nonav-manual-cors-redirects-to-nocors-nocreds',
122     redirect_dest: 'no-cors',
123     url_credentials: false,
124     expected_type: 'opaqueredirect',
125     expected_redirected: false,
126     request_init: {
127       redirect: 'manual',
128       mode: 'cors'
129     },
130     should_reject: false
131   });
132 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
133    'no-cors without credentials should succeed opaqueredirect interception ' +
134    'and response should not be redirected');
135
136 promise_test(function(t) {
137   return redirect_fetch_test(t, {
138     name: 'nonav-manual-cors-redirects-to-cors-nocreds',
139     redirect_dest: 'cors',
140     url_credentials: false,
141     expected_type: 'opaqueredirect',
142     expected_redirected: false,
143     request_init: {
144       redirect: 'manual',
145       mode: 'cors'
146     },
147     should_reject: false
148   });
149 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
150    'cors without credentials should succeed opaqueredirect interception ' +
151    'and response should not be redirected');
152
153 promise_test(function(t) {
154   return redirect_fetch_test(t, {
155     name: 'nonav-manual-sameorigin-redirects-to-sameorigin-nocreds',
156     redirect_dest: 'same-origin',
157     url_credentials: false,
158     expected_type: 'opaqueredirect',
159     expected_redirected: false,
160     request_init: {
161       redirect: 'manual',
162       mode: 'same-origin'
163     },
164     should_reject: false
165   });
166 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
167    'same-origin without credentials should succeed opaqueredirect ' +
168    'interception and response should not be redirected');
169
170 promise_test(function(t) {
171   return redirect_fetch_test(t, {
172     name: 'nonav-manual-sameorigin-redirects-to-nocors-nocreds',
173     redirect_dest: 'no-cors',
174     url_credentials: false,
175     expected_type: 'opaqueredirect',
176     expected_redirected: false,
177     request_init: {
178       redirect: 'manual',
179       mode: 'same-origin'
180     },
181     should_reject: false
182   });
183 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
184    'no-cors without credentials should succeed opaqueredirect interception ' +
185    'and response should not be redirected');
186
187 promise_test(function(t) {
188   return redirect_fetch_test(t, {
189     name: 'nonav-manual-sameorigin-redirects-to-cors-nocreds',
190     redirect_dest: 'cors',
191     url_credentials: false,
192     expected_type: 'opaqueredirect',
193     expected_redirected: false,
194     request_init: {
195       redirect: 'manual',
196       mode: 'same-origin'
197     },
198     should_reject: false
199   });
200 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
201    'cors without credentials should succeed opaqueredirect interception ' +
202    'and response should not be redirected');
203
204 promise_test(function(t) {
205   return redirect_fetch_test(t, {
206     name: 'nonav-manual-nocors-redirects-to-sameorigin-nocreds',
207     redirect_dest: 'same-origin',
208     url_credentials: false,
209     expected_type: 'opaqueredirect',
210     expected_redirected: false,
211     request_init: {
212       redirect: 'manual',
213       mode: 'no-cors'
214     },
215     should_reject: true
216   });
217 }, 'Non-navigation, manual redirect, no-cors mode Request should fail');
218
219 promise_test(function(t) {
220   return redirect_fetch_test(t, {
221     name: 'nonav-manual-cors-redirects-to-sameorigin-creds',
222     redirect_dest: 'same-origin',
223     url_credentials: true,
224     expected_type: 'opaqueredirect',
225     expected_redirected: false,
226     request_init: {
227       redirect: 'manual',
228       mode: 'cors'
229     },
230     should_reject: false
231   });
232 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
233    'same-origin with credentials should succeed opaqueredirect interception ' +
234    'and response should not be redirected');
235
236 promise_test(function(t) {
237   return redirect_fetch_test(t, {
238     name: 'nonav-manual-cors-redirects-to-nocors-creds',
239     redirect_dest: 'no-cors',
240     url_credentials: true,
241     expected_type: 'opaqueredirect',
242     expected_redirected: false,
243     request_init: {
244       redirect: 'manual',
245       mode: 'cors'
246     },
247     should_reject: false
248   });
249 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
250    'no-cors with credentials should succeed opaqueredirect interception ' +
251    'and response should not be redirected');
252
253 promise_test(function(t) {
254   return redirect_fetch_test(t, {
255     name: 'nonav-manual-cors-redirects-to-cors-creds',
256     redirect_dest: 'cors',
257     url_credentials: true,
258     expected_type: 'opaqueredirect',
259     expected_redirected: false,
260     request_init: {
261       redirect: 'manual',
262       mode: 'cors'
263     },
264     should_reject: false
265   });
266 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
267    'cors with credentials should succeed opaqueredirect interception ' +
268    'and response should not be redirected');
269
270 promise_test(function(t) {
271   return redirect_fetch_test(t, {
272     name: 'nonav-manual-sameorigin-redirects-to-sameorigin-creds',
273     redirect_dest: 'same-origin',
274     url_credentials: true,
275     expected_type: 'opaqueredirect',
276     expected_redirected: false,
277     request_init: {
278       redirect: 'manual',
279       mode: 'same-origin'
280     },
281     should_reject: false
282   });
283 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
284    'same-origin with credentials should succeed opaqueredirect interception ' +
285    'and response should not be redirected');
286
287 promise_test(function(t) {
288   return redirect_fetch_test(t, {
289     name: 'nonav-manual-sameorigin-redirects-to-nocors-creds',
290     redirect_dest: 'no-cors',
291     url_credentials: true,
292     expected_type: 'opaqueredirect',
293     expected_redirected: false,
294     request_init: {
295       redirect: 'manual',
296       mode: 'same-origin'
297     },
298     should_reject: false
299   });
300 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
301    'no-cors with credentials should succeed opaqueredirect interception ' +
302    'and response should not be redirected');
303
304 promise_test(function(t) {
305   return redirect_fetch_test(t, {
306     name: 'nonav-manual-sameorigin-redirects-to-cors-creds',
307     redirect_dest: 'cors',
308     url_credentials: true,
309     expected_type: 'opaqueredirect',
310     expected_redirected: false,
311     request_init: {
312       redirect: 'manual',
313       mode: 'same-origin'
314     },
315     should_reject: false
316   });
317 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
318    'cors with credentials should succeed opaqueredirect interception ' +
319    'and response should not be redirected');
320
321 promise_test(function(t) {
322   return redirect_fetch_test(t, {
323     name: 'nonav-follow-cors-redirects-to-sameorigin-nocreds',
324     redirect_dest: 'same-origin',
325     url_credentials: false,
326     expected_type: 'basic',
327     expected_redirected: true,
328     request_init: {
329       redirect: 'follow',
330       mode: 'cors'
331     },
332     should_reject: false
333   });
334 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
335    'same-origin without credentials should succeed interception ' +
336    'and response should be redirected');
337
338 promise_test(function(t) {
339   return redirect_fetch_test(t, {
340     name: 'nonav-follow-cors-redirects-to-nocors-nocreds',
341     redirect_dest: 'no-cors',
342     url_credentials: false,
343     request_init: {
344       redirect: 'follow',
345       mode: 'cors'
346     },
347     // should reject because CORS requests require CORS headers on cross-origin
348     // resources
349     should_reject: true
350   });
351 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
352    'no-cors without credentials should fail interception ' +
353    'and response should not be redirected');
354
355 promise_test(function(t) {
356   return redirect_fetch_test(t, {
357     name: 'nonav-follow-cors-redirects-to-cors-nocreds',
358     redirect_dest: 'cors',
359     url_credentials: false,
360     expected_type: 'cors',
361     expected_redirected: true,
362     request_init: {
363       redirect: 'follow',
364       mode: 'cors'
365     },
366     should_reject: false
367   });
368 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
369    'cors without credentials should succeed interception ' +
370    'and response should be redirected');
371
372 promise_test(function(t) {
373   return redirect_fetch_test(t, {
374     name: 'nonav-follow-sameorigin-redirects-to-sameorigin-nocreds',
375     redirect_dest: 'same-origin',
376     url_credentials: false,
377     expected_type: 'basic',
378     expected_redirected: true,
379     request_init: {
380       redirect: 'follow',
381       mode: 'same-origin'
382     },
383     should_reject: false
384   });
385 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
386    'same-origin without credentials should succeed interception ' +
387    'and response should be redirected');
388
389 promise_test(function(t) {
390   return redirect_fetch_test(t, {
391     name: 'nonav-follow-sameorigin-redirects-to-nocors-nocreds',
392     redirect_dest: 'no-cors',
393     url_credentials: false,
394     request_init: {
395       redirect: 'follow',
396       mode: 'same-origin'
397     },
398     // should reject because same-origin requests cannot load cross-origin
399     // resources
400     should_reject: true
401   });
402 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
403    'no-cors without credentials should fail interception ' +
404    'and response should not be redirected');
405
406 promise_test(function(t) {
407   return redirect_fetch_test(t, {
408     name: 'nonav-follow-sameorigin-redirects-to-cors-nocreds',
409     redirect_dest: 'cors',
410     url_credentials: false,
411     request_init: {
412       redirect: 'follow',
413       mode: 'same-origin'
414     },
415     // should reject because same-origin requests cannot load cross-origin
416     // resources
417     should_reject: true
418   });
419 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
420    'cors without credentials should fail interception ' +
421    'and response should not be redirected');
422
423 promise_test(function(t) {
424   return redirect_fetch_test(t, {
425     name: 'nonav-follow-nocors-redirects-to-sameorigin-nocreds',
426     redirect_dest: 'same-origin',
427     url_credentials: false,
428     expected_type: 'basic',
429     expected_redirected: true,
430     request_init: {
431       redirect: 'follow',
432       mode: 'no-cors'
433     },
434     should_reject: false
435   });
436 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
437    'same-origin without credentials should succeed interception ' +
438    'and response should be redirected');
439
440 promise_test(function(t) {
441   return redirect_fetch_test(t, {
442     name: 'nonav-follow-nocors-redirects-to-nocors-nocreds',
443     redirect_dest: 'no-cors',
444     url_credentials: false,
445     expected_type: 'opaque',
446     expected_redirected: false,
447     request_init: {
448       redirect: 'follow',
449       mode: 'no-cors'
450     },
451     should_reject: false
452   });
453 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
454    'no-cors without credentials should succeed interception ' +
455    'and response should not be redirected');
456
457 promise_test(function(t) {
458   return redirect_fetch_test(t, {
459     name: 'nonav-follow-nocors-redirects-to-cors-nocreds',
460     redirect_dest: 'cors',
461     url_credentials: false,
462     expected_type: 'opaque',
463     expected_redirected: false,
464     request_init: {
465       redirect: 'follow',
466       mode: 'no-cors'
467     },
468     should_reject: false
469   });
470 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
471    'cors without credentials should succeed interception ' +
472    'and response should not be redirected');
473
474 promise_test(function(t) {
475   return redirect_fetch_test(t, {
476     name: 'nonav-follow-cors-redirects-to-sameorigin-creds',
477     redirect_dest: 'same-origin',
478     url_credentials: true,
479     expected_type: 'basic',
480     expected_redirected: true,
481     request_init: {
482       redirect: 'follow',
483       mode: 'cors'
484     },
485     should_reject: false
486   });
487 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
488    'same-origin with credentials should succeed interception ' +
489    'and response should be redirected');
490
491 promise_test(function(t) {
492   return redirect_fetch_test(t, {
493     name: 'nonav-follow-cors-redirects-to-nocors-creds',
494     redirect_dest: 'no-cors',
495     url_credentials: true,
496     request_init: {
497       redirect: 'follow',
498       mode: 'cors'
499     },
500     // should reject because CORS requests require CORS headers on cross-origin
501     // resources
502     should_reject: true
503   });
504 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
505    'no-cors with credentials should fail interception ' +
506    'and response should not be redirected');
507
508 promise_test(function(t) {
509   return redirect_fetch_test(t, {
510     name: 'nonav-follow-cors-redirects-to-cors-creds',
511     redirect_dest: 'cors',
512     url_credentials: true,
513     request_init: {
514       redirect: 'follow',
515       mode: 'cors'
516     },
517     // should reject because CORS requests do not allow user/pass entries in
518     // cross-origin URLs
519     // NOTE: https://github.com/whatwg/fetch/issues/112
520     should_reject: true
521   });
522 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
523    'cors with credentials should fail interception ' +
524    'and response should be redirected');
525
526 promise_test(function(t) {
527   return redirect_fetch_test(t, {
528     name: 'nonav-follow-sameorigin-redirects-to-sameorigin-creds',
529     redirect_dest: 'same-origin',
530     url_credentials: true,
531     expected_type: 'basic',
532     expected_redirected: true,
533     request_init: {
534       redirect: 'follow',
535       mode: 'same-origin'
536     },
537     should_reject: false
538   });
539 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
540    'same-origin with credentials should succeed interception ' +
541    'and response should be redirected');
542
543 promise_test(function(t) {
544   return redirect_fetch_test(t, {
545     name: 'nonav-follow-sameorigin-redirects-to-nocors-creds',
546     redirect_dest: 'no-cors',
547     url_credentials: true,
548     request_init: {
549       redirect: 'follow',
550       mode: 'same-origin'
551     },
552     // should reject because same-origin requests cannot load cross-origin
553     // resources
554     should_reject: true
555   });
556 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
557    'no-cors with credentials should fail interception ' +
558    'and response should not be redirected');
559
560 promise_test(function(t) {
561   return redirect_fetch_test(t, {
562     name: 'nonav-follow-sameorigin-redirects-to-cors-creds',
563     redirect_dest: 'cors',
564     url_credentials: true,
565     request_init: {
566       redirect: 'follow',
567       mode: 'same-origin'
568     },
569     // should reject because same-origin requests cannot load cross-origin
570     // resources
571     should_reject: true
572   });
573 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
574    'cors with credentials should fail interception ' +
575    'and response should not be redirected');
576
577 promise_test(function(t) {
578   return redirect_fetch_test(t, {
579     name: 'nonav-follow-nocors-redirects-to-sameorigin-creds',
580     redirect_dest: 'same-origin',
581     url_credentials: true,
582     expected_type: 'basic',
583     expected_redirected: true,
584     request_init: {
585       redirect: 'follow',
586       mode: 'no-cors'
587     },
588     should_reject: false
589   });
590 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
591    'same-origin with credentials should succeed interception ' +
592    'and response should be redirected');
593
594 promise_test(function(t) {
595   return redirect_fetch_test(t, {
596     name: 'nonav-follow-nocors-redirects-to-nocors-creds',
597     redirect_dest: 'no-cors',
598     url_credentials: true,
599     expected_type: 'opaque',
600     expected_redirected: false,
601     request_init: {
602       redirect: 'follow',
603       mode: 'no-cors'
604     },
605     should_reject: false
606   });
607 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
608    'no-cors with credentials should succeed interception ' +
609    'and response should not be redirected');
610
611 promise_test(function(t) {
612   return redirect_fetch_test(t, {
613     name: 'nonav-follow-nocors-redirects-to-cors-creds',
614     redirect_dest: 'cors',
615     url_credentials: true,
616     expected_type: 'opaque',
617     expected_redirected: false,
618     request_init: {
619       redirect: 'follow',
620       mode: 'no-cors'
621     },
622     should_reject: false
623   });
624 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
625    'cors with credentials should succeed interception ' +
626    'and response should not be redirected');
627
628 promise_test(function(t) {
629   return redirect_fetch_test(t, {
630     name: 'nonav-error-cors-redirects-to-sameorigin-nocreds',
631     redirect_dest: 'same-origin',
632     url_credentials: false,
633     request_init: {
634       redirect: 'error',
635       mode: 'cors'
636     },
637     // should reject because requests with 'error' RequestRedirect cannot be
638     // redirected.
639     should_reject: true
640   });
641 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
642    'same-origin without credentials should fail interception ' +
643    'and response should not be redirected');
644
645 promise_test(function(t) {
646   return redirect_fetch_test(t, {
647     name: 'nonav-error-cors-redirects-to-nocors-nocreds',
648     redirect_dest: 'no-cors',
649     url_credentials: false,
650     request_init: {
651       redirect: 'error',
652       mode: 'cors'
653     },
654     // should reject because requests with 'error' RequestRedirect cannot be
655     // redirected.
656     should_reject: true
657   });
658 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
659    'no-cors without credentials should fail interception ' +
660    'and response should not be redirected');
661
662 promise_test(function(t) {
663   return redirect_fetch_test(t, {
664     name: 'nonav-error-cors-redirects-to-cors-nocreds',
665     redirect_dest: 'cors',
666     url_credentials: false,
667     request_init: {
668       redirect: 'error',
669       mode: 'cors'
670     },
671     // should reject because requests with 'error' RequestRedirect cannot be
672     // redirected.
673     should_reject: true
674   });
675 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
676    'cors without credentials should fail interception ' +
677    'and response should not be redirected');
678
679 promise_test(function(t) {
680   return redirect_fetch_test(t, {
681     name: 'nonav-error-sameorigin-redirects-to-sameorigin-nocreds',
682     redirect_dest: 'same-origin',
683     url_credentials: false,
684     request_init: {
685       redirect: 'error',
686       mode: 'same-origin'
687     },
688     // should reject because requests with 'error' RequestRedirect cannot be
689     // redirected.
690     should_reject: true
691   });
692 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
693    'same-origin without credentials should fail interception ' +
694    'and response should not be redirected');
695
696 promise_test(function(t) {
697   return redirect_fetch_test(t, {
698     name: 'nonav-error-sameorigin-redirects-to-nocors-nocreds',
699     redirect_dest: 'no-cors',
700     url_credentials: false,
701     request_init: {
702       redirect: 'error',
703       mode: 'same-origin'
704     },
705     // should reject because requests with 'error' RequestRedirect cannot be
706     // redirected.
707     should_reject: true
708   });
709 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
710    'no-cors without credentials should fail interception ' +
711    'and response should not be redirected');
712
713 promise_test(function(t) {
714   return redirect_fetch_test(t, {
715     name: 'nonav-error-sameorigin-redirects-to-cors-nocreds',
716     redirect_dest: 'cors',
717     url_credentials: false,
718     request_init: {
719       redirect: 'error',
720       mode: 'same-origin'
721     },
722     // should reject because requests with 'error' RequestRedirect cannot be
723     // redirected.
724     should_reject: true
725   });
726 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
727    'cors without credentials should fail interception ' +
728    'and response should not be redirected');
729
730 promise_test(function(t) {
731   return redirect_fetch_test(t, {
732     name: 'nonav-error-nocors-redirects-to-sameorigin-nocreds',
733     redirect_dest: 'same-origin',
734     url_credentials: false,
735     request_init: {
736       redirect: 'error',
737       mode: 'no-cors'
738     },
739     // should reject because error + no-cors is not allowed.
740     should_reject: true
741   });
742 }, 'Non-navigation, error redirect, no-cors mode Request should fail');
743
744 promise_test(function(t) {
745   return redirect_fetch_test(t, {
746     name: 'nonav-error-cors-redirects-to-sameorigin-creds',
747     redirect_dest: 'same-origin',
748     url_credentials: true,
749     request_init: {
750       redirect: 'error',
751       mode: 'cors'
752     },
753     // should reject because requests with 'error' RequestRedirect cannot be
754     // redirected.
755     should_reject: true
756   });
757 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
758    'same-origin with credentials should fail interception ' +
759    'and response should not be redirected');
760
761 promise_test(function(t) {
762   return redirect_fetch_test(t, {
763     name: 'nonav-error-cors-redirects-to-nocors-creds',
764     redirect_dest: 'no-cors',
765     url_credentials: true,
766     request_init: {
767       redirect: 'error',
768       mode: 'cors'
769     },
770     // should reject because requests with 'error' RequestRedirect cannot be
771     // redirected.
772     should_reject: true
773   });
774 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
775    'no-cors with credentials should fail interception ' +
776    'and response should not be redirected');
777
778 promise_test(function(t) {
779   return redirect_fetch_test(t, {
780     name: 'nonav-error-cors-redirects-to-cors-creds',
781     redirect_dest: 'cors',
782     url_credentials: true,
783     request_init: {
784       redirect: 'error',
785       mode: 'cors'
786     },
787     // should reject because requests with 'error' RequestRedirect cannot be
788     // redirected.
789     should_reject: true
790   });
791 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
792    'cors with credentials should fail interception ' +
793    'and response should not be redirected');
794
795 promise_test(function(t) {
796   return redirect_fetch_test(t, {
797     name: 'nonav-error-sameorigin-redirects-to-sameorigin-creds',
798     redirect_dest: 'same-origin',
799     url_credentials: true,
800     request_init: {
801       redirect: 'error',
802       mode: 'same-origin'
803     },
804     // should reject because requests with 'error' RequestRedirect cannot be
805     // redirected.
806     should_reject: true
807   });
808 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
809    'same-origin with credentials should fail interception ' +
810    'and response should not be redirected');
811
812 promise_test(function(t) {
813   return redirect_fetch_test(t, {
814     name: 'nonav-error-sameorigin-redirects-to-nocors-creds',
815     redirect_dest: 'no-cors',
816     url_credentials: true,
817     request_init: {
818       redirect: 'error',
819       mode: 'same-origin'
820     },
821     // should reject because requests with 'error' RequestRedirect cannot be
822     // redirected.
823     should_reject: true
824   });
825 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
826    'no-cors with credentials should fail interception ' +
827    'and response should not be redirected');
828
829 promise_test(function(t) {
830   return redirect_fetch_test(t, {
831     name: 'nonav-error-sameorigin-redirects-to-cors-creds',
832     redirect_dest: 'cors',
833     url_credentials: true,
834     request_init: {
835       redirect: 'error',
836       mode: 'same-origin'
837     },
838     // should reject because requests with 'error' RequestRedirect cannot be
839     // redirected.
840     should_reject: true
841   });
842 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
843    'cors with credentials should fail interception ' +
844    'and response should not be redirected');
845 </script>
846 </body>