The Tor Browser: services/common/tests/unit/test

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* Any copyright is dedicated to the Public Domain.

     2    http://creativecommons.org/publicdomain/zero/1.0/ */

     4 "use strict";

     6 Cu.import("resource://gre/modules/NetUtil.jsm");

     7 Cu.import("resource://gre/modules/Log.jsm");

     8 Cu.import("resource://services-common/rest.js");

     9 Cu.import("resource://services-common/utils.js");

    11 function run_test() {

    12   Log.repository.getLogger("Services.Common.RESTRequest").level =

    13     Log.Level.Trace;

    14   initTestLogging("Trace");

    16   run_next_test();

    17 }

    19 /**

    20  * Initializing a RESTRequest with an invalid URI throws

    21  * NS_ERROR_MALFORMED_URI.

    22  */

    23 add_test(function test_invalid_uri() {

    24   do_check_throws(function() {

    25     new RESTRequest("an invalid URI");

    26   }, Cr.NS_ERROR_MALFORMED_URI);

    27   run_next_test();

    28 });

    30 /**

    31  * Verify initial values for attributes.

    32  */

    33 add_test(function test_attributes() {

    34   let uri = "http://foo.com/bar/baz";

    35   let request = new RESTRequest(uri);

    37   do_check_true(request.uri instanceof Ci.nsIURI);

    38   do_check_eq(request.uri.spec, uri);

    39   do_check_eq(request.response, null);

    40   do_check_eq(request.status, request.NOT_SENT);

    41   let expectedLoadFlags = Ci.nsIRequest.LOAD_BYPASS_CACHE |

    42                           Ci.nsIRequest.INHIBIT_CACHING |

    43                           Ci.nsIRequest.LOAD_ANONYMOUS;

    44   do_check_eq(request.loadFlags, expectedLoadFlags);

    46   run_next_test();

    47 });

    49 /**

    50  * Verify that a proxy auth redirect doesn't break us. This has to be the first

    51  * request made in the file!

    52  */

    53 add_test(function test_proxy_auth_redirect() {

    54   let pacFetched = false;

    55   function pacHandler(metadata, response) {

    56     pacFetched = true;

    57     let body = 'function FindProxyForURL(url, host) { return "DIRECT"; }';

    58     response.setStatusLine(metadata.httpVersion, 200, "OK");

    59     response.setHeader("Content-Type", "application/x-ns-proxy-autoconfig", false);

    60     response.bodyOutputStream.write(body, body.length);

    61   }

    63   let fetched = false;

    64   function original(metadata, response) {

    65     fetched = true;

    66     let body = "TADA!";

    67     response.setStatusLine(metadata.httpVersion, 200, "OK");

    68     response.bodyOutputStream.write(body, body.length);

    69   }

    71   let server = httpd_setup({

    72     "/original": original,

    73     "/pac3":     pacHandler

    74   });

    75   PACSystemSettings.PACURI = server.baseURI + "/pac3";

    76   installFakePAC();

    78   let res = new RESTRequest(server.baseURI + "/original");

    79   res.get(function (error) {

    80     do_check_true(pacFetched);

    81     do_check_true(fetched);

    82     do_check_true(!error);

    83     do_check_true(this.response.success);

    84     do_check_eq("TADA!", this.response.body);

    85     uninstallFakePAC();

    86     server.stop(run_next_test);

    87   });

    88 });

    90 /**

    91  * Ensure that failures that cause asyncOpen to throw

    92  * result in callbacks being invoked.

    93  * Bug 826086.

    94  */

    95 add_test(function test_forbidden_port() {

    96   let request = new RESTRequest("http://localhost:6000/");

    97   request.get(function(error) {

    98     if (!error) {

    99       do_throw("Should have got an error.");

   100     }

   101     do_check_eq(error.result, Components.results.NS_ERROR_PORT_ACCESS_NOT_ALLOWED);

   102     run_next_test();

   103   });

   104 });

   106 /**

   107  * Demonstrate API short-hand: create a request and dispatch it immediately.

   108  */

   109 add_test(function test_simple_get() {

   110   let handler = httpd_handler(200, "OK", "Huzzah!");

   111   let server = httpd_setup({"/resource": handler});

   113   let request = new RESTRequest(server.baseURI + "/resource").get(function (error) {

   114     do_check_eq(error, null);

   116     do_check_eq(this.status, this.COMPLETED);

   117     do_check_true(this.response.success);

   118     do_check_eq(this.response.status, 200);

   119     do_check_eq(this.response.body, "Huzzah!");

   121     server.stop(run_next_test);

   122   });

   123   do_check_eq(request.status, request.SENT);

   124   do_check_eq(request.method, "GET");

   125 });

   127 /**

   128  * Test HTTP GET with all bells and whistles.

   129  */

   130 add_test(function test_get() {

   131   let handler = httpd_handler(200, "OK", "Huzzah!");

   132   let server = httpd_setup({"/resource": handler});

   134   let request = new RESTRequest(server.baseURI + "/resource");

   135   do_check_eq(request.status, request.NOT_SENT);

   137   request.onProgress = request.onComplete = function () {

   138     do_throw("This function should have been overwritten!");

   139   };

   141   let onProgress_called = false;

   142   function onProgress() {

   143     onProgress_called = true;

   144     do_check_eq(this.status, request.IN_PROGRESS);

   145     do_check_true(this.response.body.length > 0);

   147     do_check_true(!!(this.channel.loadFlags & Ci.nsIRequest.LOAD_BYPASS_CACHE));

   148     do_check_true(!!(this.channel.loadFlags & Ci.nsIRequest.INHIBIT_CACHING));

   149   };

   151   function onComplete(error) {

   152     do_check_eq(error, null);

   154     do_check_eq(this.status, this.COMPLETED);

   155     do_check_true(this.response.success);

   156     do_check_eq(this.response.status, 200);

   157     do_check_eq(this.response.body, "Huzzah!");

   158     do_check_eq(handler.request.method, "GET");

   160     do_check_true(onProgress_called);

   161     CommonUtils.nextTick(function () {

   162       do_check_eq(request.onComplete, null);

   163       do_check_eq(request.onProgress, null);

   164       server.stop(run_next_test);

   165     });

   166   };

   168   do_check_eq(request.get(onComplete, onProgress), request);

   169   do_check_eq(request.status, request.SENT);

   170   do_check_eq(request.method, "GET");

   171   do_check_throws(function () {

   172     request.get();

   173   });

   174 });

   176 /**

   177  * Test HTTP GET with UTF-8 content, and custom Content-Type.

   178  */

   179 add_test(function test_get_utf8() {

   180   let response = "Hello World or Καλημέρα κόσμε or こんにちは 世界";

   182   let contentType = "text/plain";

   183   let charset = true;

   184   let charsetSuffix = "; charset=UTF-8";

   186   let server = httpd_setup({"/resource": function(req, res) {

   187     res.setStatusLine(req.httpVersion, 200, "OK");

   188     res.setHeader("Content-Type", contentType + (charset ? charsetSuffix : ""));

   190     let converter = Cc["@mozilla.org/intl/converter-output-stream;1"]

   191                     .createInstance(Ci.nsIConverterOutputStream);

   192     converter.init(res.bodyOutputStream, "UTF-8", 0, 0x0000);

   193     converter.writeString(response);

   194     converter.close();

   195   }});

   197   // Check if charset in Content-Type is propertly interpreted.

   198   let request1 = new RESTRequest(server.baseURI + "/resource");

   199   request1.get(function(error) {

   200     do_check_null(error);

   202     do_check_eq(request1.response.status, 200);

   203     do_check_eq(request1.response.body, response);

   204     do_check_eq(request1.response.headers["content-type"],

   205                 contentType + charsetSuffix);

   207     // Check that we default to UTF-8 if Content-Type doesn't have a charset.

   208     charset = false;

   209     let request2 = new RESTRequest(server.baseURI + "/resource");

   210     request2.get(function(error) {

   211       do_check_null(error);

   213       do_check_eq(request2.response.status, 200);

   214       do_check_eq(request2.response.body, response);

   215       do_check_eq(request2.response.headers["content-type"], contentType);

   216       do_check_eq(request2.response.charset, "utf-8");

   218       server.stop(run_next_test);

   219     });

   220   });

   221 });

   223 /**

   224  * Test more variations of charset handling.

   225  */

   226 add_test(function test_charsets() {

   227   let response = "Hello World, I can't speak Russian";

   229   let contentType = "text/plain";

   230   let charset = true;

   231   let charsetSuffix = "; charset=us-ascii";

   233   let server = httpd_setup({"/resource": function(req, res) {

   234     res.setStatusLine(req.httpVersion, 200, "OK");

   235     res.setHeader("Content-Type", contentType + (charset ? charsetSuffix : ""));

   237     let converter = Cc["@mozilla.org/intl/converter-output-stream;1"]

   238                     .createInstance(Ci.nsIConverterOutputStream);

   239     converter.init(res.bodyOutputStream, "us-ascii", 0, 0x0000);

   240     converter.writeString(response);

   241     converter.close();

   242   }});

   244   // Check that provided charset overrides hint.

   245   let request1 = new RESTRequest(server.baseURI + "/resource");

   246   request1.charset = "not-a-charset";

   247   request1.get(function(error) {

   248     do_check_null(error);

   250     do_check_eq(request1.response.status, 200);

   251     do_check_eq(request1.response.body, response);

   252     do_check_eq(request1.response.headers["content-type"],

   253                 contentType + charsetSuffix);

   254     do_check_eq(request1.response.charset, "us-ascii");

   256     // Check that hint is used if Content-Type doesn't have a charset.

   257     charset = false;

   258     let request2 = new RESTRequest(server.baseURI + "/resource");

   259     request2.charset = "us-ascii";

   260     request2.get(function(error) {

   261       do_check_null(error);

   263       do_check_eq(request2.response.status, 200);

   264       do_check_eq(request2.response.body, response);

   265       do_check_eq(request2.response.headers["content-type"], contentType);

   266       do_check_eq(request2.response.charset, "us-ascii");

   268       server.stop(run_next_test);

   269     });

   270   });

   271 });

   273 /**

   274  * Test HTTP PUT with a simple string argument and default Content-Type.

   275  */

   276 add_test(function test_put() {

   277   let handler = httpd_handler(200, "OK", "Got it!");

   278   let server = httpd_setup({"/resource": handler});

   280   let request = new RESTRequest(server.baseURI + "/resource");

   281   do_check_eq(request.status, request.NOT_SENT);

   283   request.onProgress = request.onComplete = function () {

   284     do_throw("This function should have been overwritten!");

   285   };

   287   let onProgress_called = false;

   288   function onProgress() {

   289     onProgress_called = true;

   290     do_check_eq(this.status, request.IN_PROGRESS);

   291     do_check_true(this.response.body.length > 0);

   292   };

   294   function onComplete(error) {

   295     do_check_eq(error, null);

   297     do_check_eq(this.status, this.COMPLETED);

   298     do_check_true(this.response.success);

   299     do_check_eq(this.response.status, 200);

   300     do_check_eq(this.response.body, "Got it!");

   302     do_check_eq(handler.request.method, "PUT");

   303     do_check_eq(handler.request.body, "Hullo?");

   304     do_check_eq(handler.request.getHeader("Content-Type"), "text/plain");

   306     do_check_true(onProgress_called);

   307     CommonUtils.nextTick(function () {

   308       do_check_eq(request.onComplete, null);

   309       do_check_eq(request.onProgress, null);

   310       server.stop(run_next_test);

   311     });

   312   };

   314   do_check_eq(request.put("Hullo?", onComplete, onProgress), request);

   315   do_check_eq(request.status, request.SENT);

   316   do_check_eq(request.method, "PUT");

   317   do_check_throws(function () {

   318     request.put("Hai!");

   319   });

   320 });

   322 /**

   323  * Test HTTP POST with a simple string argument and default Content-Type.

   324  */

   325 add_test(function test_post() {

   326   let handler = httpd_handler(200, "OK", "Got it!");

   327   let server = httpd_setup({"/resource": handler});

   329   let request = new RESTRequest(server.baseURI + "/resource");

   330   do_check_eq(request.status, request.NOT_SENT);

   332   request.onProgress = request.onComplete = function () {

   333     do_throw("This function should have been overwritten!");

   334   };

   336   let onProgress_called = false;

   337   function onProgress() {

   338     onProgress_called = true;

   339     do_check_eq(this.status, request.IN_PROGRESS);

   340     do_check_true(this.response.body.length > 0);

   341   };

   343   function onComplete(error) {

   344     do_check_eq(error, null);

   346     do_check_eq(this.status, this.COMPLETED);

   347     do_check_true(this.response.success);

   348     do_check_eq(this.response.status, 200);

   349     do_check_eq(this.response.body, "Got it!");

   351     do_check_eq(handler.request.method, "POST");

   352     do_check_eq(handler.request.body, "Hullo?");

   353     do_check_eq(handler.request.getHeader("Content-Type"), "text/plain");

   355     do_check_true(onProgress_called);

   356     CommonUtils.nextTick(function () {

   357       do_check_eq(request.onComplete, null);

   358       do_check_eq(request.onProgress, null);

   359       server.stop(run_next_test);

   360     });

   361   };

   363   do_check_eq(request.post("Hullo?", onComplete, onProgress), request);

   364   do_check_eq(request.status, request.SENT);

   365   do_check_eq(request.method, "POST");

   366   do_check_throws(function () {

   367     request.post("Hai!");

   368   });

   369 });

   371 /**

   372  * Test HTTP DELETE.

   373  */

   374 add_test(function test_delete() {

   375   let handler = httpd_handler(200, "OK", "Got it!");

   376   let server = httpd_setup({"/resource": handler});

   378   let request = new RESTRequest(server.baseURI + "/resource");

   379   do_check_eq(request.status, request.NOT_SENT);

   381   request.onProgress = request.onComplete = function () {

   382     do_throw("This function should have been overwritten!");

   383   };

   385   let onProgress_called = false;

   386   function onProgress() {

   387     onProgress_called = true;

   388     do_check_eq(this.status, request.IN_PROGRESS);

   389     do_check_true(this.response.body.length > 0);

   390   };

   392   function onComplete(error) {

   393     do_check_eq(error, null);

   395     do_check_eq(this.status, this.COMPLETED);

   396     do_check_true(this.response.success);

   397     do_check_eq(this.response.status, 200);

   398     do_check_eq(this.response.body, "Got it!");

   399     do_check_eq(handler.request.method, "DELETE");

   401     do_check_true(onProgress_called);

   402     CommonUtils.nextTick(function () {

   403       do_check_eq(request.onComplete, null);

   404       do_check_eq(request.onProgress, null);

   405       server.stop(run_next_test);

   406     });

   407   };

   409   do_check_eq(request.delete(onComplete, onProgress), request);

   410   do_check_eq(request.status, request.SENT);

   411   do_check_eq(request.method, "DELETE");

   412   do_check_throws(function () {

   413     request.delete();

   414   });

   415 });

   417 /**

   418  * Test an HTTP response with a non-200 status code.

   419  */

   420 add_test(function test_get_404() {

   421   let handler = httpd_handler(404, "Not Found", "Cannae find it!");

   422   let server = httpd_setup({"/resource": handler});

   424   let request = new RESTRequest(server.baseURI + "/resource");

   425   request.get(function (error) {

   426     do_check_eq(error, null);

   428     do_check_eq(this.status, this.COMPLETED);

   429     do_check_false(this.response.success);

   430     do_check_eq(this.response.status, 404);

   431     do_check_eq(this.response.body, "Cannae find it!");

   433     server.stop(run_next_test);

   434   });

   435 });

   437 /**

   438  * The 'data' argument to PUT, if not a string already, is automatically

   439  * stringified as JSON.

   440  */

   441 add_test(function test_put_json() {

   442   let handler = httpd_handler(200, "OK");

   443   let server = httpd_setup({"/resource": handler});

   445   let sample_data = {

   446     some: "sample_data",

   447     injson: "format",

   448     number: 42

   449   };

   450   let request = new RESTRequest(server.baseURI + "/resource");

   451   request.put(sample_data, function (error) {

   452     do_check_eq(error, null);

   454     do_check_eq(this.status, this.COMPLETED);

   455     do_check_true(this.response.success);

   456     do_check_eq(this.response.status, 200);

   457     do_check_eq(this.response.body, "");

   459     do_check_eq(handler.request.method, "PUT");

   460     do_check_eq(handler.request.body, JSON.stringify(sample_data));

   461     do_check_eq(handler.request.getHeader("Content-Type"), "text/plain");

   463     server.stop(run_next_test);

   464   });

   465 });

   467 /**

   468  * The 'data' argument to POST, if not a string already, is automatically

   469  * stringified as JSON.

   470  */

   471 add_test(function test_post_json() {

   472   let handler = httpd_handler(200, "OK");

   473   let server = httpd_setup({"/resource": handler});

   475   let sample_data = {

   476     some: "sample_data",

   477     injson: "format",

   478     number: 42

   479   };

   480   let request = new RESTRequest(server.baseURI + "/resource");

   481   request.post(sample_data, function (error) {

   482     do_check_eq(error, null);

   484     do_check_eq(this.status, this.COMPLETED);

   485     do_check_true(this.response.success);

   486     do_check_eq(this.response.status, 200);

   487     do_check_eq(this.response.body, "");

   489     do_check_eq(handler.request.method, "POST");

   490     do_check_eq(handler.request.body, JSON.stringify(sample_data));

   491     do_check_eq(handler.request.getHeader("Content-Type"), "text/plain");

   493     server.stop(run_next_test);

   494   });

   495 });

   497 /**

   498  * HTTP PUT with a custom Content-Type header.

   499  */

   500 add_test(function test_put_override_content_type() {

   501   let handler = httpd_handler(200, "OK");

   502   let server = httpd_setup({"/resource": handler});

   504   let request = new RESTRequest(server.baseURI + "/resource");

   505   request.setHeader("Content-Type", "application/lolcat");

   506   request.put("O HAI!!1!", function (error) {

   507     do_check_eq(error, null);

   509     do_check_eq(this.status, this.COMPLETED);

   510     do_check_true(this.response.success);

   511     do_check_eq(this.response.status, 200);

   512     do_check_eq(this.response.body, "");

   514     do_check_eq(handler.request.method, "PUT");

   515     do_check_eq(handler.request.body, "O HAI!!1!");

   516     do_check_eq(handler.request.getHeader("Content-Type"), "application/lolcat");

   518     server.stop(run_next_test);

   519   });

   520 });

   522 /**

   523  * HTTP POST with a custom Content-Type header.

   524  */

   525 add_test(function test_post_override_content_type() {

   526   let handler = httpd_handler(200, "OK");

   527   let server = httpd_setup({"/resource": handler});

   529   let request = new RESTRequest(server.baseURI + "/resource");

   530   request.setHeader("Content-Type", "application/lolcat");

   531   request.post("O HAI!!1!", function (error) {

   532     do_check_eq(error, null);

   534     do_check_eq(this.status, this.COMPLETED);

   535     do_check_true(this.response.success);

   536     do_check_eq(this.response.status, 200);

   537     do_check_eq(this.response.body, "");

   539     do_check_eq(handler.request.method, "POST");

   540     do_check_eq(handler.request.body, "O HAI!!1!");

   541     do_check_eq(handler.request.getHeader("Content-Type"), "application/lolcat");

   543     server.stop(run_next_test);

   544   });

   545 });

   547 /**

   548  * No special headers are sent by default on a GET request.

   549  */

   550 add_test(function test_get_no_headers() {

   551   let handler = httpd_handler(200, "OK");

   552   let server = httpd_setup({"/resource": handler});

   554   let ignore_headers = ["host", "user-agent", "accept", "accept-language",

   555                         "accept-encoding", "accept-charset", "keep-alive",

   556                         "connection", "pragma", "cache-control",

   557                         "content-length"];

   559   new RESTRequest(server.baseURI + "/resource").get(function (error) {

   560     do_check_eq(error, null);

   562     do_check_eq(this.response.status, 200);

   563     do_check_eq(this.response.body, "");

   565     let server_headers = handler.request.headers;

   566     while (server_headers.hasMoreElements()) {

   567       let header = server_headers.getNext().toString();

   568       if (ignore_headers.indexOf(header) == -1) {

   569         do_throw("Got unexpected header!");

   570       }

   571     }

   573     server.stop(run_next_test);

   574   });

   575 });

   577 /**

   578  * Test changing the URI after having created the request.

   579  */

   580 add_test(function test_changing_uri() {

   581   let handler = httpd_handler(200, "OK");

   582   let server = httpd_setup({"/resource": handler});

   584   let request = new RESTRequest("http://localhost:1234/the-wrong-resource");

   585   request.uri = CommonUtils.makeURI(server.baseURI + "/resource");

   586   request.get(function (error) {

   587     do_check_eq(error, null);

   588     do_check_eq(this.response.status, 200);

   589     server.stop(run_next_test);

   590   });

   591 });

   593 /**

   594  * Test setting HTTP request headers.

   595  */

   596 add_test(function test_request_setHeader() {

   597   let handler = httpd_handler(200, "OK");

   598   let server = httpd_setup({"/resource": handler});

   600   let request = new RESTRequest(server.baseURI + "/resource");

   602   request.setHeader("X-What-Is-Weave", "awesome");

   603   request.setHeader("X-WHAT-is-Weave", "more awesomer");

   604   request.setHeader("Another-Header", "Hello World");

   606   request.get(function (error) {

   607     do_check_eq(error, null);

   609     do_check_eq(this.response.status, 200);

   610     do_check_eq(this.response.body, "");

   612     do_check_eq(handler.request.getHeader("X-What-Is-Weave"), "more awesomer");

   613     do_check_eq(handler.request.getHeader("another-header"), "Hello World");

   615     server.stop(run_next_test);

   616   });

   617 });

   619 /**

   620  * Test receiving HTTP response headers.

   621  */

   622 add_test(function test_response_headers() {

   623   function handler(request, response) {

   624     response.setHeader("X-What-Is-Weave", "awesome");

   625     response.setHeader("Another-Header", "Hello World");

   626     response.setStatusLine(request.httpVersion, 200, "OK");

   627   }

   628   let server = httpd_setup({"/resource": handler});

   629   let request = new RESTRequest(server.baseURI + "/resource");

   631   request.get(function (error) {

   632     do_check_eq(error, null);

   634     do_check_eq(this.response.status, 200);

   635     do_check_eq(this.response.body, "");

   637     do_check_eq(this.response.headers["x-what-is-weave"], "awesome");

   638     do_check_eq(this.response.headers["another-header"], "Hello World");

   640     server.stop(run_next_test);

   641   });

   642 });

   644 /**

   645  * The onComplete() handler gets called in case of any network errors

   646  * (e.g. NS_ERROR_CONNECTION_REFUSED).

   647  */

   648 add_test(function test_connection_refused() {

   649   let request = new RESTRequest("http://localhost:1234/resource");

   650   request.onProgress = function onProgress() {

   651     do_throw("Shouldn't have called request.onProgress()!");

   652   };

   653   request.get(function (error) {

   654     do_check_eq(error.result, Cr.NS_ERROR_CONNECTION_REFUSED);

   655     do_check_eq(error.message, "NS_ERROR_CONNECTION_REFUSED");

   656     do_check_eq(this.status, this.COMPLETED);

   657     run_next_test();

   658   });

   659   do_check_eq(request.status, request.SENT);

   660 });

   662 /**

   663  * Abort a request that just sent off.

   664  */

   665 add_test(function test_abort() {

   666   function handler() {

   667     do_throw("Shouldn't have gotten here!");

   668   }

   669   let server = httpd_setup({"/resource": handler});

   671   let request = new RESTRequest(server.baseURI + "/resource");

   673   // Aborting a request that hasn't been sent yet is pointless and will throw.

   674   do_check_throws(function () {

   675     request.abort();

   676   });

   678   request.onProgress = request.onComplete = function () {

   679     do_throw("Shouldn't have gotten here!");

   680   };

   681   request.get();

   682   request.abort();

   684   // Aborting an already aborted request is pointless and will throw.

   685   do_check_throws(function () {

   686     request.abort();

   687   });

   689   do_check_eq(request.status, request.ABORTED);

   690   CommonUtils.nextTick(function () {

   691     server.stop(run_next_test);

   692   });

   693 });

   695 /**

   696  * A non-zero 'timeout' property specifies the amount of seconds to wait after

   697  * channel activity until the request is automatically canceled.

   698  */

   699 add_test(function test_timeout() {

   700   let server = new HttpServer();

   701   let server_connection;

   702   server._handler.handleResponse = function(connection) {

   703     // This is a handler that doesn't do anything, just keeps the connection

   704     // open, thereby mimicking a timing out connection. We keep a reference to

   705     // the open connection for later so it can be properly disposed of. That's

   706     // why you really only want to make one HTTP request to this server ever.

   707     server_connection = connection;

   708   };

   709   server.start();

   710   let identity = server.identity;

   711   let uri = identity.primaryScheme + "://" + identity.primaryHost + ":" +

   712             identity.primaryPort;

   714   let request = new RESTRequest(uri + "/resource");

   715   request.timeout = 0.1; // 100 milliseconds

   716   request.get(function (error) {

   717     do_check_eq(error.result, Cr.NS_ERROR_NET_TIMEOUT);

   718     do_check_eq(this.status, this.ABORTED);

   720     // server_connection is undefined on the Android emulator for reasons

   721     // unknown. Yet, we still get here. If this test is refactored, we should

   722     // investigate the reason why the above callback is behaving differently.

   723     if (server_connection) {

   724       _("Closing connection.");

   725       server_connection.close();

   726     }

   728     _("Shutting down server.");

   729     server.stop(run_next_test);

   730   });

   731 });

   733 /**

   734  * An exception thrown in 'onProgress' propagates to the 'onComplete' handler.

   735  */

   736 add_test(function test_exception_in_onProgress() {

   737   let handler = httpd_handler(200, "OK", "Foobar");

   738   let server = httpd_setup({"/resource": handler});

   740   let request = new RESTRequest(server.baseURI + "/resource");

   741   request.onProgress = function onProgress() {

   742     it.does.not.exist();

   743   };

   744   request.get(function onComplete(error) {

   745     do_check_eq(error, "ReferenceError: it is not defined");

   746     do_check_eq(this.status, this.ABORTED);

   748     server.stop(run_next_test);

   749   });

   750 });

   752 add_test(function test_new_channel() {

   753   _("Ensure a redirect to a new channel is handled properly.");

   755   function checkUA(metadata) {

   756     let ua = metadata.getHeader("User-Agent");

   757     _("User-Agent is " + ua);

   758     do_check_eq("foo bar", ua);

   759   }

   761   let redirectRequested = false;

   762   let redirectURL;

   763   function redirectHandler(metadata, response) {

   764     checkUA(metadata);

   765     redirectRequested = true;

   767     let body = "Redirecting";

   768     response.setStatusLine(metadata.httpVersion, 307, "TEMPORARY REDIRECT");

   769     response.setHeader("Location", redirectURL);

   770     response.bodyOutputStream.write(body, body.length);

   771   }

   773   let resourceRequested = false;

   774   function resourceHandler(metadata, response) {

   775     checkUA(metadata);

   776     resourceRequested = true;

   778     let body = "Test";

   779     response.setHeader("Content-Type", "text/plain");

   780     response.bodyOutputStream.write(body, body.length);

   781   }

   783   let server1 = httpd_setup({"/redirect": redirectHandler});

   784   let server2 = httpd_setup({"/resource": resourceHandler});

   785   redirectURL = server2.baseURI + "/resource";

   787   function advance() {

   788     server1.stop(function () {

   789       server2.stop(run_next_test);

   790     });

   791   }

   793   let request = new RESTRequest(server1.baseURI + "/redirect");

   794   request.setHeader("User-Agent", "foo bar");

   796   // Swizzle in our own fakery, because this redirect is neither

   797   // internal nor URI-preserving. RESTRequest's policy is to only

   798   // copy headers under certain circumstances.

   799   let protoMethod = request.shouldCopyOnRedirect;

   800   request.shouldCopyOnRedirect = function wrapped(o, n, f) {

   801     // Check the default policy.

   802     do_check_false(protoMethod.call(this, o, n, f));

   803     return true;

   804   };

   806   request.get(function onComplete(error) {

   807     let response = this.response;

   809     do_check_eq(200, response.status);

   810     do_check_eq("Test", response.body);

   811     do_check_true(redirectRequested);

   812     do_check_true(resourceRequested);

   814     advance();

   815   });

   816 });

   818 add_test(function test_not_sending_cookie() {

   819   function handler(metadata, response) {

   820     let body = "COOKIE!";

   821     response.setStatusLine(metadata.httpVersion, 200, "OK");

   822     response.bodyOutputStream.write(body, body.length);

   823     do_check_false(metadata.hasHeader("Cookie"));

   824   }

   825   let server = httpd_setup({"/test": handler});

   827   let cookieSer = Cc["@mozilla.org/cookieService;1"]

   828                     .getService(Ci.nsICookieService);

   829   let uri = CommonUtils.makeURI(server.baseURI);

   830   cookieSer.setCookieString(uri, null, "test=test; path=/;", null);

   832   let res = new RESTRequest(server.baseURI + "/test");

   833   res.get(function (error) {

   834     do_check_null(error);

   835     do_check_true(this.response.success);

   836     do_check_eq("COOKIE!", this.response.body);

   837     server.stop(run_next_test);

   838   });

   839 });

The Tor Browser / file revision

services/common/tests/unit/test_restrequest.js@6474c204b198

services/common/tests/unit/test_restrequest.js