src/third_party/WebKit/LayoutTests/http/tests/serviceworker/resources/request-worker.js

   1 importScripts('worker-test-harness.js');
   2
   3 var URL = 'https://www.example.com/test.html';
   4
   5 test(function() {
   6     var headers = new Headers;
   7     headers.set('User-Agent', 'Mozilla/5.0');
   8     headers.set('Accept', 'text/html');
   9     headers.set('X-ServiceWorker-Test', 'request test field');
  10
  11     var request = new Request(URL, {method: 'GET', headers: headers});
  12
  13     assert_equals(request.url, URL, 'Request.url should match');
  14     assert_equals(request.method, 'GET', 'Request.method should match');
  15     assert_equals(request.referrer, location.href, 'Request.referrer should match');
  16     assert_true(request.headers instanceof Headers, 'Request.headers should be Headers');
  17
  18     // 'User-Agent' is a forbidden header.
  19     assert_equals(request.headers.size, 2, 'Request.headers.size should match');
  20     // Note: detailed behavioral tests for Headers are in another test,
  21     // http/tests/serviceworker/headers.html.
  22
  23     request.url = 'http://localhost/';
  24     assert_equals(request.url, 'https://www.example.com/test.html', 'Request.url should be readonly');
  25     request = new Request('http://localhost/\uD800'); // Unmatched lead surrogate.
  26     assert_equals(request.url,
  27                   'http://localhost/' + encodeURIComponent('\uFFFD'),
  28                   'Request.url should have unmatched surrogates replaced.');
  29     request.method = 'POST';
  30     assert_equals(request.method, 'GET', 'Request.method should be readonly');
  31 }, 'Request basic test in ServiceWorkerGlobalScope');
  32
  33 test(function() {
  34     [new Request(URL),
  35      new Request(URL, {method: ''}),
  36      new Request(URL, {mode: ''}),
  37      new Request(URL, {mode: 'invalid mode'}),
  38      new Request(URL, {credentials: ''}),
  39      new Request(URL, {credentials: 'invalid credentials'})].forEach(function(request) {
  40         assert_equals(request.url, URL, 'Request.url should match');
  41         assert_equals(request.method, 'GET', 'Default Request.method should be GET');
  42         assert_equals(request.mode, 'cors', 'Default Request.mode should be cors');
  43         assert_equals(request.credentials, 'omit', 'Default Request.credentials should be omit');
  44     });
  45 }, 'Request default value test in ServiceWorkerGlobalScope');
  46
  47 test(function() {
  48     var request = new Request(URL);
  49     request.headers.append('X-ServiceWorker-Foo', 'foo1');
  50     request.headers.append('X-ServiceWorker-Foo', 'foo2');
  51     request.headers.append('X-ServiceWorker-Bar', 'bar');
  52     var request2 = new Request(request);
  53     assert_equals(request2.url, URL, 'Request.url should match');
  54     assert_equals(request2.method, 'GET', 'Request.method should match');
  55     assert_equals(request2.mode, 'cors', 'Request.mode should match');
  56     assert_equals(request2.credentials, 'omit', 'Request.credentials should match');
  57     assert_equals(request2.headers.getAll('X-ServiceWorker-Foo')[0], 'foo1',
  58                   'Request.headers should match');
  59     assert_equals(request2.headers.getAll('X-ServiceWorker-Foo')[1], 'foo2',
  60                   'Request.headers should match');
  61     assert_equals(request2.headers.getAll('X-ServiceWorker-Bar')[0], 'bar',
  62                   'Request.headers should match');
  63 }, 'Request header test in ServiceWorkerGlobalScope');
  64
  65 test(function() {
  66     var request1 = {};
  67     var request2 = {};
  68     var METHODS = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS', '', undefined];
  69     var MODES = ['same-origin', 'no-cors', 'cors', '', undefined];
  70     function isSimpleMethod(method) {
  71       return ['GET', 'HEAD', 'POST', '', undefined].indexOf(method) != -1;
  72     };
  73     function effectiveMethod(method1, method2) {
  74       return method2 ? method2 : (method1 ? method1 : 'GET');
  75     };
  76     function effectiveMode(mode1, mode2) {
  77       return mode2 ? mode2 : (mode1 ? mode1 : 'cors');
  78     };
  79     METHODS.forEach(function(method1) {
  80         MODES.forEach(function(mode1) {
  81             var init1 = {};
  82             if (method1 != undefined) { init1['method'] = method1; }
  83             if (mode1 != undefined) { init1['mode'] = mode1; }
  84             if (!isSimpleMethod(method1) && mode1 == 'no-cors') {
  85                 assert_throws(
  86                     {name:'TypeError'},
  87                     function() { request1 = new Request(URL, init1); },
  88                     'new no-cors Request with non simple method (' + method1 +') should throw');
  89                 return;
  90             }
  91             request1 = new Request(URL, init1);
  92             assert_equals(request1.method, method1 ? method1 : 'GET', 'Request.method should match');
  93             assert_equals(request1.mode, mode1 ? mode1 : 'cors', 'Request.mode should match');
  94             request1 = new Request(request1);
  95             assert_equals(request1.method, method1 ? method1 : 'GET', 'Request.method should match');
  96             assert_equals(request1.mode, mode1 ? mode1 : 'cors', 'Request.mode should match');
  97             METHODS.forEach(function(method2) {
  98                 MODES.forEach(function(mode2) {
  99                     var init2 = {};
 100                     if (method2 != undefined) { init2['method'] = method2; }
 101                     if (mode2 != undefined) { init2['mode'] = mode2; }
 102                     if (!isSimpleMethod(effectiveMethod(method1, method2)) && effectiveMode(mode1, mode2) == 'no-cors') {
 103                         assert_throws(
 104                             {name:'TypeError'},
 105                             function() { request2 = new Request(request1, init2); },
 106                             'new no-cors Request with non simple method should throw');
 107                         return;
 108                     }
 109                     request2 = new Request(request1, init2);
 110                     assert_equals(request2.method,
 111                                   method2 ? method2 : request1.method,
 112                                   'Request.method should be overridden');
 113                     assert_equals(request2.mode,
 114                                   mode2 ? mode2 : request1.mode,
 115                                   'Request.mode should be overridden');
 116                 });
 117             });
 118         });
 119     });
 120 }, 'Request header test in ServiceWorkerGlobalScope');
 121
 122 test(function() {
 123     var request1 = {};
 124     var request2 = {};
 125     var CREDENTIALS = ['omit', 'same-origin', 'include', '', undefined];
 126     CREDENTIALS.forEach(function(credentials1) {
 127         var init1 = {};
 128         if (credentials1 != undefined) { init1['credentials'] = credentials1; }
 129         request1 = new Request(URL, init1);
 130         assert_equals(request1.credentials, credentials1 ? credentials1 : 'omit', 'Request.credentials should match');
 131         request1 = new Request(request1);
 132         assert_equals(request1.credentials, credentials1 ? credentials1 : 'omit', 'Request.credentials should match');
 133         CREDENTIALS.forEach(function(credentials2) {
 134             var init2 = {};
 135             if (credentials2 != undefined) { init2['credentials'] = credentials2; }
 136             request2 = new Request(request1, init2);
 137             assert_equals(request2.credentials,
 138                           credentials2 ? credentials2 : request1.credentials,
 139                           'Request.credentials should be overridden');
 140         });
 141     });
 142 }, 'Request credentials test in ServiceWorkerGlobalScope');
 143
 144 test(function() {
 145     ['same-origin', 'cors', 'no-cors'].forEach(function(mode) {
 146         var forbiddenMethods = ['TRACE', 'TRACK', 'CONNECT'];
 147         forbiddenMethods.forEach(function(method) {
 148             assert_throws(
 149                 {name:'TypeError'},
 150                 function() { var request = new Request(URL, {mode: mode, method: method}); },
 151                 'new Request with a forbidden method (' + method +') should throw');
 152         });
 153         var invalidNames = ['(', ')', '<', '>', '@', ',', ';', ':', '\\', '"',
 154                             '/', '[', ']', '?', '=', '{', '}', '\u3042', 'a(b',
 155                             'invalid name'];
 156         invalidNames.forEach(function(name) {
 157             assert_throws(
 158                 {name:'TypeError'},
 159                 function() { var request = new Request(URL, {mode: mode, method: name}); },
 160                 'new Request with an invalid method (' + name +') should throw');
 161         });
 162     });
 163 }, 'Request method name test in ServiceWorkerGlobalScope');
 164
 165 test(function() {
 166     var FORBIDDEN_HEADERS =
 167         ['Accept-Charset', 'Accept-Encoding', 'Access-Control-Request-Headers',
 168          'Access-Control-Request-Method', 'Connection', 'Content-Length', 'Cookie',
 169          'Cookie2', 'Date', 'DNT', 'Expect', 'Host', 'Keep-Alive', 'Origin',
 170          'Referer', 'TE', 'Trailer', 'Transfer-Encoding', 'Upgrade', 'User-Agent',
 171          'Via', 'Proxy-', 'Sec-', 'Proxy-FooBar', 'Sec-FooBar'];
 172     var SIMPLE_HEADERS =
 173         [['Accept', '*'], ['Accept-Language', 'ru'], ['Content-Language', 'ru'],
 174          ['Content-Type', 'application/x-www-form-urlencoded'],
 175          ['Content-Type', 'multipart/form-data'],
 176          ['Content-Type', 'text/plain']];
 177     var NON_SIMPLE_HEADERS =
 178         [['X-ServiceWorker-Test', 'test'],
 179          ['X-ServiceWorker-Test2', 'test2'],
 180          ['Content-Type', 'foo/bar']];
 181
 182     ['same-origin', 'cors'].forEach(function(mode) {
 183         var request = new Request(URL, {mode: mode});
 184         FORBIDDEN_HEADERS.forEach(function(header) {
 185             request.headers.append(header, 'test');
 186             assert_equals(request.headers.size, 0,
 187                           'Request.headers.append should ignore the forbidden headers');
 188             request.headers.set(header, 'test');
 189             assert_equals(request.headers.size, 0,
 190                           'Request.headers.set should ignore the forbidden headers');
 191         });
 192         var request = new Request(URL, {mode: mode});
 193         assert_equals(request.headers.size, 0);
 194         NON_SIMPLE_HEADERS.forEach(function(header) {
 195             request.headers.append(header[0], header[1]);
 196         });
 197         assert_equals(request.headers.size, NON_SIMPLE_HEADERS.length);
 198         NON_SIMPLE_HEADERS.forEach(function(header) {
 199             assert_equals(request.headers.get(header[0]), header[1]);
 200         });
 201         request = new Request(URL, {mode: mode});
 202         assert_equals(request.headers.size, 0);
 203         NON_SIMPLE_HEADERS.forEach(function(header) {
 204             request.headers.set(header[0], header[1]);
 205         });
 206         assert_equals(request.headers.size, NON_SIMPLE_HEADERS.length);
 207         NON_SIMPLE_HEADERS.forEach(function(header) {
 208             assert_equals(request.headers.get(header[0]), header[1]);
 209         });
 210     });
 211     request = new Request(URL, {mode: 'no-cors'});
 212     FORBIDDEN_HEADERS.forEach(function(header) {
 213         request.headers.set(header, 'test');
 214         request.headers.append(header, 'test');
 215     });
 216     NON_SIMPLE_HEADERS.forEach(function(header) {
 217         request.headers.set(header[0], header[1]);
 218         request.headers.append(header[0], header[1]);
 219     });
 220     assert_equals(request.headers.size, 0,
 221                   'no-cors request should only accept simple headers');
 222
 223     SIMPLE_HEADERS.forEach(function(header) {
 224         request = new Request(URL, {mode: 'no-cors'});
 225         request.headers.append(header[0], header[1]);
 226         assert_equals(request.headers.size, 1,
 227                       'no-cors request should accept simple headers');
 228         request = new Request(URL, {mode: 'no-cors'});
 229         request.headers.set(header[0], header[1]);
 230         assert_equals(request.headers.size, 1,
 231                       'no-cors request should accept simple headers');
 232         request.headers.delete(header[0]);
 233         if (header[0] == 'Content-Type') {
 234             assert_equals(
 235                 request.headers.size, 1,
 236                 'Content-Type header of no-cors request shouldn\'t be deleted');
 237         } else {
 238             assert_equals(request.headers.size, 0);
 239         }
 240     });
 241
 242     SIMPLE_HEADERS.forEach(function(header) {
 243         var headers = {};
 244         NON_SIMPLE_HEADERS.forEach(function(header2) {
 245             headers[header2[0]] = header2[1];
 246         });
 247         FORBIDDEN_HEADERS.forEach(function(header) { headers[header] = 'foo'; });
 248         headers[header[0]] = header[1];
 249         var expectedSize = NON_SIMPLE_HEADERS.length;
 250         if (header[0] != 'Content-Type') {
 251             ++expectedSize;
 252         }
 253         ['same-origin', 'cors'].forEach(function(mode) {
 254           request = new Request(URL, {mode: mode, headers: headers});
 255           assert_equals(request.headers.size, expectedSize,
 256                         'Request should not support the forbidden headers');
 257         });
 258         request = new Request(URL, {mode: 'no-cors', headers: headers});
 259         assert_equals(request.headers.size, 1,
 260                       'No-CORS Request.headers should only support simple headers');
 261         ['same-origin', 'cors', 'no-cors'].forEach(function(mode) {
 262             request = new Request(new Request(URL, {mode: mode, headers: headers}), {mode: 'no-cors'});
 263             assert_equals(request.headers.size, 1,
 264                           'No-CORS Request.headers should only support simple headers');
 265         });
 266     });
 267 }, 'Request headers test in ServiceWorkerGlobalScope');