The Tor Browser: addon-sdk/source/test/test-request.js@ac0c01689b40

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this

     3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     5 const { Request } = require("sdk/request");

     6 const { pathFor } = require("sdk/system");

     7 const file = require("sdk/io/file");

     8 const { URL } = require("sdk/url");

     9 const { extend } = require("sdk/util/object");

    10 const { Loader } = require("sdk/test/loader");

    11 const options = require("@test/options");

    13 const loader = Loader(module);

    14 const httpd = loader.require("sdk/test/httpd");

    15 if (options.parseable || options.verbose)

    16   loader.sandbox("sdk/test/httpd").DEBUG = true;

    17 const { startServerAsync } = httpd;

    19 const { Cc, Ci, Cu } = require("chrome");

    20 const { Services } = Cu.import("resource://gre/modules/Services.jsm");

    22 // Use the profile directory for the temporary files as that will be deleted

    23 // when tests are complete

    24 const basePath = pathFor("ProfD");

    25 const port = 8099;

    28 exports.testOptionsValidator = function(assert) {

    29   // First, a simple test to make sure we didn't break normal functionality.

    30   assert.throws(function () {

    31     Request({

    32       url: null

    33     });

    34   }, /The option "url" is invalid./);

    36   // Next we'll have a Request that doesn't throw from c'tor, but from a setter.

    37   let req = Request({

    38     url: "http://playground.zpao.com/jetpack/request/text.php",

    39     onComplete: function () {}

    40   });

    41   assert.throws(function () {

    42     req.url = 'www.mozilla.org';

    43   }, /The option "url" is invalid/);

    44   // The url shouldn't have changed, so check that

    45   assert.equal(req.url, "http://playground.zpao.com/jetpack/request/text.php");

    46 };

    48 exports.testContentValidator = function(assert, done) {

    49   runMultipleURLs(null, assert, done, {

    50     url: "data:text/html;charset=utf-8,response",

    51     content: { 'key1' : null, 'key2' : 'some value' },

    52     onComplete: function(response) {

    53       assert.equal(response.text, "response?key1=null&key2=some+value");

    54     }

    55   });

    56 };

    58 // This is a request to a file that exists.

    59 exports.testStatus200 = function (assert, done) {

    60   let srv = startServerAsync(port, basePath);

    61   let content = "Look ma, no hands!\n";

    62   let basename = "test-request.txt"

    63   prepareFile(basename, content);

    65   var req = Request({

    66     url: "http://localhost:" + port + "/" + basename,

    67     onComplete: function (response) {

    68       assert.equal(this, req, "`this` should be request");

    69       assert.equal(response.status, 200);

    70       assert.equal(response.statusText, "OK");

    71       assert.equal(response.headers["Content-Type"], "text/plain");

    72       assert.equal(response.text, content);

    73       srv.stop(done);

    74     }

    75   }).get();

    76 };

    78 // This tries to get a file that doesn't exist

    79 exports.testStatus404 = function (assert, done) {

    80   var srv = startServerAsync(port, basePath);

    82   runMultipleURLs(srv, assert, done, {

    83     // the following URL doesn't exist

    84     url: "http://localhost:" + port + "/test-request-404.txt",

    85     onComplete: function (response) {

    86       assert.equal(response.status, 404);

    87       assert.equal(response.statusText, "Not Found");

    88     }

    89   });

    90 };

    92 // a simple file with a known header

    93 exports.testKnownHeader = function (assert, done) {

    94   var srv = startServerAsync(port, basePath);

    96  // Create the file that will be requested with the associated headers file

    97   let content = "This tests adding headers to the server's response.\n";

    98   let basename = "test-request-headers.txt";

    99   let headerContent = "x-jetpack-header: Jamba Juice\n";

   100   let headerBasename = "test-request-headers.txt^headers^";

   101   prepareFile(basename, content);

   102   prepareFile(headerBasename, headerContent);

   104   runMultipleURLs(srv, assert, done, {

   105     url: "http://localhost:" + port + "/test-request-headers.txt",

   106     onComplete: function (response) {

   107       assert.equal(response.headers["x-jetpack-header"], "Jamba Juice");

   108     }

   109   });

   110 };

   112 // complex headers

   113 exports.testComplexHeader = function (assert, done) {

   114   let srv = startServerAsync(port, basePath);

   116   let basename = "test-request-complex-headers.sjs";

   117   let content = handleRequest.toString();

   118   prepareFile(basename, content);

   120   let headers = {

   121     "x-jetpack-header": "Jamba Juice is: delicious",

   122     "x-jetpack-header-2": "foo,bar",

   123     "x-jetpack-header-3": "sup dawg, i heard you like x, so we put a x in " +

   124       "yo x so you can y while you y",

   125     "Set-Cookie": "foo=bar\nbaz=foo"

   126   };

   128   runMultipleURLs(srv, assert, done, {

   129     url: "http://localhost:" + port + "/test-request-complex-headers.sjs",

   130     onComplete: function (response) {

   131       for (k in headers) {

   132         assert.equal(response.headers[k], headers[k]);

   133       }

   134     }

   135   });

   136 };

   138 // Force Allow Third Party cookies

   139 exports.test3rdPartyCookies = function (assert, done) {

   140   let srv = startServerAsync(port, basePath);

   142   let basename = "test-request-3rd-party-cookies.sjs";

   144   // Function to handle the requests in the server

   145   let content = function handleRequest(request, response) {

   146     var cookiePresent = request.hasHeader("Cookie");

   147     // If no cookie, set it

   148     if(!cookiePresent) {

   149       response.setHeader("Set-Cookie", "cookie=monster;", "true");

   150       response.setHeader("x-jetpack-3rd-party", "false", "true");

   151     } else {

   152       // We got the cookie, say so

   153       response.setHeader("x-jetpack-3rd-party", "true", "true");

   154     }

   156     response.write("<html><body>This tests 3rd party cookies.</body></html>");

   157   }.toString();

   159   prepareFile(basename, content);

   161   // Disable the 3rd party cookies

   162   Services.prefs.setIntPref("network.cookie.cookieBehavior", 1);

   164   Request({

   165     url: "http://localhost:" + port + "/test-request-3rd-party-cookies.sjs",

   166     onComplete: function (response) {

   167       // Check that the server created the cookie

   168       assert.equal(response.headers['Set-Cookie'], 'cookie=monster;');

   170       // Check it wasn't there before

   171       assert.equal(response.headers['x-jetpack-3rd-party'], 'false');

   173       // Make a second request, and check that the server this time

   174       // got the cookie

   175       Request({

   176         url: "http://localhost:" + port + "/test-request-3rd-party-cookies.sjs",

   177         onComplete: function (response) {

   178           assert.equal(response.headers['x-jetpack-3rd-party'], 'true');

   179           srv.stop(done);

   180         }

   181       }).get();

   182     }

   183   }).get();

   184 };

   186 exports.testSimpleJSON = function (assert, done) {

   187   let srv = startServerAsync(port, basePath);

   188   let json = { foo: "bar" };

   189   let basename = "test-request.json";

   190   prepareFile(basename, JSON.stringify(json));

   192   runMultipleURLs(srv, assert, done, {

   193     url: "http://localhost:" + port + "/" + basename,

   194     onComplete: function (response) {

   195       assert.deepEqual(response.json, json);

   196     }

   197   });

   198 };

   200 exports.testInvalidJSON = function (assert, done) {

   201   let srv = startServerAsync(port, basePath);

   202   let basename = "test-request-invalid.json";

   203   prepareFile(basename, '"this": "isn\'t JSON"');

   205   runMultipleURLs(srv, assert, done, {

   206     url: "http://localhost:" + port + "/" + basename,

   207     onComplete: function (response) {

   208       assert.equal(response.json, null);

   209     }

   210   });

   211 };

   213 exports.testDelete = function (assert, done) {

   214   let srv = startServerAsync(port, basePath);

   216   srv.registerPathHandler("/test-delete",

   217       function handle(request, response) {

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

   219   });

   221   Request({

   222     url: "http://localhost:" + port + "/test-delete",

   223     onComplete: function (response) {

   224       // We cannot access the METHOD of the request to verify it's set

   225       // correctly.

   226       assert.equal(response.text, "");

   227       assert.equal(response.statusText, "OK");

   228       assert.equal(response.headers["Content-Type"], "text/plain");

   229       srv.stop(done);

   230     }

   231   }).delete();

   232 };

   234 exports.testHead = function (assert, done) {

   235   let srv = startServerAsync(port, basePath);

   237   srv.registerPathHandler("/test-head",

   238       function handle(request, response) {

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

   240   });

   242   Request({

   243     url: "http://localhost:" + port + "/test-head",

   244     onComplete: function (response) {

   245       assert.equal(response.text, "");

   246       assert.equal(response.statusText, "OK");

   247       assert.equal(response.headers["Content-Type"], "text/plain");

   248       srv.stop(done);

   249     }

   250   }).head();

   251 };

   253 function runMultipleURLs (srv, assert, done, options) {

   254   let urls = [options.url, URL(options.url)];

   255   let cb = options.onComplete;

   256   let ran = 0;

   257   let onComplete = function (res) {

   258     cb(res);

   259     if (++ran === urls.length)

   260       srv ? srv.stop(done) : done();

   261   };

   262   urls.forEach(function (url) {

   263     Request(extend(options, { url: url, onComplete: onComplete })).get();

   264   });

   265 }

   267 // All tests below here require a network connection. They will be commented out

   268 // when checked in. If you'd like to run them, simply uncomment them.

   269 //

   270 // When we have the means, these tests will be converted so that they don't

   271 // require an external server nor a network connection.

   273 /*

   274 exports.testGetWithParamsNotContent = function (assert, done) {

   275   Request({

   276     url: "http://playground.zpao.com/jetpack/request/getpost.php?foo=bar",

   277     onComplete: function (response) {

   278       let expected = {

   279         "POST": [],

   280         "GET" : { foo: "bar" }

   281       };

   282       assert.deepEqual(response.json, expected);

   283       done();

   284     }

   285   }).get();

   286 }

   288 exports.testGetWithContent = function (assert, done) {

   289   Request({

   290     url: "http://playground.zpao.com/jetpack/request/getpost.php",

   291     content: { foo: "bar" },

   292     onComplete: function (response) {

   293       let expected = {

   294         "POST": [],

   295         "GET" : { foo: "bar" }

   296       };

   297       assert.deepEqual(response.json, expected);

   298       done();

   299     }

   300   }).get();

   301 }

   303 exports.testGetWithParamsAndContent = function (assert, done) {

   304   Request({

   305     url: "http://playground.zpao.com/jetpack/request/getpost.php?foo=bar",

   306     content: { baz: "foo" },

   307     onComplete: function (response) {

   308       let expected = {

   309         "POST": [],

   310         "GET" : { foo: "bar", baz: "foo" }

   311       };

   312       assert.deepEqual(response.json, expected);

   313       done();

   314     }

   315   }).get();

   316 }

   318 exports.testSimplePost = function (assert, done) {

   319   Request({

   320     url: "http://playground.zpao.com/jetpack/request/getpost.php",

   321     content: { foo: "bar" },

   322     onComplete: function (response) {

   323       let expected = {

   324         "POST": { foo: "bar" },

   325         "GET" : []

   326       };

   327       assert.deepEqual(response.json, expected);

   328       done();

   329     }

   330   }).post();

   331 }

   333 exports.testEncodedContent = function (assert, done) {

   334   Request({

   335     url: "http://playground.zpao.com/jetpack/request/getpost.php",

   336     content: "foo=bar&baz=foo",

   337     onComplete: function (response) {

   338       let expected = {

   339         "POST": [],

   340         "GET" : { foo: "bar", baz: "foo" }

   341       };

   342       assert.deepEqual(response.json, expected);

   343       done();

   344     }

   345   }).get();

   346 }

   348 exports.testEncodedContentWithSpaces = function (assert, done) {

   349   Request({

   350     url: "http://playground.zpao.com/jetpack/request/getpost.php",

   351     content: "foo=bar+hop!&baz=foo",

   352     onComplete: function (response) {

   353       let expected = {

   354         "POST": [],

   355         "GET" : { foo: "bar hop!", baz: "foo" }

   356       };

   357       assert.deepEqual(response.json, expected);

   358       done();

   359     }

   360   }).get();

   361 }

   363 exports.testGetWithArray = function (assert, done) {

   364   Request({

   365     url: "http://playground.zpao.com/jetpack/request/getpost.php",

   366     content: { foo: [1, 2], baz: "foo" },

   367     onComplete: function (response) {

   368       let expected = {

   369         "POST": [],

   370         "GET" : { foo: [1, 2], baz: "foo" }

   371       };

   372       assert.deepEqual(response.json, expected);

   373       done();

   374     }

   375   }).get();

   376 }

   378 exports.testGetWithNestedArray = function (assert, done) {

   379   Request({

   380     url: "http://playground.zpao.com/jetpack/request/getpost.php",

   381     content: { foo: [1, 2, [3, 4]], bar: "baz" },

   382     onComplete: function (response) {

   383       let expected = {

   384         "POST": [],

   385         "GET" : this.content

   386       };

   387       assert.deepEqual(response.json, expected);

   388       done();

   389     }

   390   }).get();

   391 }

   393 exports.testGetWithNestedArray = function (assert, done) {

   394   let request = Request({

   395     url: "http://playground.zpao.com/jetpack/request/getpost.php",

   396     content: {

   397       foo: [1, 2, {

   398         omg: "bbq",

   399         "all your base!": "are belong to us"

   400       }],

   401       bar: "baz"

   402     },

   403     onComplete: function (response) {

   404       let expected = {

   405         "POST": [],

   406         "GET" : request.content

   407       };

   408       assert.deepEqual(response.json, expected);

   409       done();

   410     }

   411   }).get();

   412 }

   413 */

   415 function prepareFile(basename, content) {

   416   let filePath = file.join(basePath, basename);

   417   let fileStream = file.open(filePath, 'w');

   418   fileStream.write(content);

   419   fileStream.close();

   420 }

   422 // Helper function for testComplexHeaders

   423 function handleRequest(request, response) {

   424   // Test header with an extra colon

   425   response.setHeader("x-jetpack-header", "Jamba Juice is: delicious", "true");

   427   // Test that multiple headers with the same name coalesce

   428   response.setHeader("x-jetpack-header-2", "foo", "true");

   429   response.setHeader("x-jetpack-header-2", "bar", "true");

   431   // Test that headers with commas work

   432   response.setHeader("x-jetpack-header-3", "sup dawg, i heard you like x, " +

   433     "so we put a x in yo x so you can y while you y", "true");

   435   // Test that multiple cookies work

   436   response.setHeader("Set-Cookie", "foo=bar", "true");

   437   response.setHeader("Set-Cookie", "baz=foo", "true");

   439   response.write("<html><body>This file tests more complex headers.</body></html>");

   440 }

   442 require('sdk/test').run(exports);

The Tor Browser / file revision

addon-sdk/source/test/test-request.js@ac0c01689b40

addon-sdk/source/test/test-request.js