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/Log.jsm");

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

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

    10 function do_register_cleanup() {

    11   Services.prefs.resetUserPrefs();

    13   // remove the pref change listener

    14   let hawk = new HAWKAuthenticatedRESTRequest("https://example.com");

    15   hawk._intl.uninit();

    16 }

    18 function run_test() {

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

    20     Log.Level.Trace;

    21   initTestLogging("Trace");

    23   run_next_test();

    24 }

    27 add_test(function test_intl_accept_language() {

    28   let testCount = 0;

    29   let languages = [

    30     "zu-NP;vo",     // Nepalese dialect of Zulu, defaulting to Volapük

    31     "fa-CG;ik",     // Congolese dialect of Farsei, defaulting to Inupiaq

    32   ];

    34   function setLanguagePref(lang) {

    35     let acceptLanguage = Cc["@mozilla.org/supports-string;1"]

    36                            .createInstance(Ci.nsISupportsString);

    37     acceptLanguage.data = lang;

    38     Services.prefs.setComplexValue(

    39       "intl.accept_languages", Ci.nsISupportsString, acceptLanguage);

    40   }

    42   let hawk = new HAWKAuthenticatedRESTRequest("https://example.com");

    44   Services.prefs.addObserver("intl.accept_languages", checkLanguagePref, false);

    45   setLanguagePref(languages[testCount]);

    47   function checkLanguagePref() {

    48     var _done = false;

    49     CommonUtils.nextTick(function() {

    50       // Ensure we're only called for the number of entries in languages[].

    51       do_check_true(testCount < languages.length);

    53       do_check_eq(hawk._intl.accept_languages, languages[testCount]);

    55       testCount++;

    56       if (testCount < languages.length) {

    57         // Set next language in prefs; Pref service will call checkNextLanguage.

    58         setLanguagePref(languages[testCount]);

    59         return;

    60       }

    62       // We've checked all the entries in languages[]. Cleanup and move on.

    63       do_print("Checked " + testCount + " languages. Removing checkLanguagePref as pref observer.");

    64       Services.prefs.removeObserver("intl.accept_languages", checkLanguagePref);

    65       run_next_test();

    66       return;

    67     });

    68   }

    69 });

    71 add_test(function test_hawk_authenticated_request() {

    72   let onProgressCalled = false;

    73   let postData = {your: "data"};

    75   // An arbitrary date - Feb 2, 1971.  It ends in a bunch of zeroes to make our

    76   // computation with the hawk timestamp easier, since hawk throws away the

    77   // millisecond values.

    78   let then = 34329600000;

    80   let clockSkew = 120000;

    81   let timeOffset = -1 * clockSkew;

    82   let localTime = then + clockSkew;

    84   // Set the accept-languages pref to the Nepalese dialect of Zulu.

    85   let acceptLanguage = Cc['@mozilla.org/supports-string;1'].createInstance(Ci.nsISupportsString);

    86   acceptLanguage.data = 'zu-NP'; // omit trailing ';', which our HTTP libs snip

    87   Services.prefs.setComplexValue('intl.accept_languages', Ci.nsISupportsString, acceptLanguage);

    89   let credentials = {

    90     id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",

    91     key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",

    92     algorithm: "sha256"

    93   };

    95   let server = httpd_setup({

    96     "/elysium": function(request, response) {

    97       do_check_true(request.hasHeader("Authorization"));

    99       // check that the header timestamp is our arbitrary system date, not

   100       // today's date.  Note that hawk header timestamps are in seconds, not

   101       // milliseconds.

   102       let authorization = request.getHeader("Authorization");

   103       let tsMS = parseInt(/ts="(\d+)"/.exec(authorization)[1], 10) * 1000;

   104       do_check_eq(tsMS, then);

   106       // This testing can be a little wonky. In an environment where

   107       //   pref("intl.accept_languages") === 'en-US, en'

   108       // the header is sent as:

   109       //   'en-US,en;q=0.5'

   110       // hence our fake value for acceptLanguage.

   111       let lang = request.getHeader("Accept-Language");

   112       do_check_eq(lang, acceptLanguage);

   114       let message = "yay";

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

   116       response.bodyOutputStream.write(message, message.length);

   117     }

   118   });

   120   function onProgress() {

   121     onProgressCalled = true;

   122   }

   124   function onComplete(error) {

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

   126     do_check_eq(this.response.body, "yay");

   127     do_check_true(onProgressCalled);

   129     Services.prefs.resetUserPrefs();

   130     let pref = Services.prefs.getComplexValue(

   131       "intl.accept_languages", Ci.nsIPrefLocalizedString);

   132     do_check_neq(acceptLanguage.data, pref.data);

   134     server.stop(run_next_test);

   135   }

   137   let url = server.baseURI + "/elysium";

   138   let extra = {

   139     now: localTime,

   140     localtimeOffsetMsec: timeOffset

   141   };

   143   let request = new HAWKAuthenticatedRESTRequest(url, credentials, extra);

   145   // Allow hawk._intl to respond to the language pref change

   146   CommonUtils.nextTick(function() {

   147     request.post(postData, onComplete, onProgress);

   148   });

   149 });

   151 add_test(function test_hawk_language_pref_changed() {

   152   let languages = [

   153     "zu-NP",        // Nepalese dialect of Zulu

   154     "fa-CG",        // Congolese dialect of Farsi

   155   ];

   157   let credentials = {

   158     id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",

   159     key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",

   160     algorithm: "sha256",

   161   };

   163   function setLanguage(lang) {

   164     let acceptLanguage = Cc["@mozilla.org/supports-string;1"].createInstance(Ci.nsISupportsString);

   165     acceptLanguage.data = lang;

   166     Services.prefs.setComplexValue("intl.accept_languages", Ci.nsISupportsString, acceptLanguage);

   167   }

   169   let server = httpd_setup({

   170     "/foo": function(request, response) {

   171       do_check_eq(languages[1], request.getHeader("Accept-Language"));

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

   174     },

   175   });

   177   let url = server.baseURI + "/foo";

   178   let postData = {};

   179   let request;

   181   setLanguage(languages[0]);

   183   // A new request should create the stateful object for tracking the current

   184   // language.

   185   request = new HAWKAuthenticatedRESTRequest(url, credentials);

   186   CommonUtils.nextTick(testFirstLanguage);

   188   function testFirstLanguage() {

   189     do_check_eq(languages[0], request._intl.accept_languages);

   191     // Change the language pref ...

   192     setLanguage(languages[1]);

   193     CommonUtils.nextTick(testRequest);

   194   }

   196   function testRequest() {

   197     // Change of language pref should be picked up, which we can see on the

   198     // server by inspecting the request headers.

   199     request = new HAWKAuthenticatedRESTRequest(url, credentials);

   200     request.post({}, function(error) {

   201       do_check_null(error);

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

   204       Services.prefs.resetUserPrefs();

   206       server.stop(run_next_test);

   207     });

   208   }

   209 });

The Tor Browser / file revision