netwerk/test/unit/test_cookiejars.js

   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/. */
   4
   5 /*
   6  *  Test that channels with different LoadInfo
   7  *  are stored in separate namespaces ("cookie jars")
   8  */
   9
  10 "use strict";
  11
  12 ChromeUtils.defineLazyGetter(this, "URL", function () {
  13   return "http://localhost:" + httpserver.identity.primaryPort;
  14 });
  15
  16 const { HttpServer } = ChromeUtils.importESModule(
  17   "resource://testing-common/httpd.sys.mjs"
  18 );
  19
  20 var httpserver = new HttpServer();
  21
  22 var cookieSetPath = "/setcookie";
  23 var cookieCheckPath = "/checkcookie";
  24
  25 function inChildProcess() {
  26   return Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
  27 }
  28
  29 // Test array:
  30 //  - element 0: name for cookie, used both to set and later to check
  31 //  - element 1: loadInfo (determines cookie namespace)
  32 //
  33 // TODO: bug 722850: make private browsing work per-app, and add tests.  For now
  34 // all values are 'false' for PB.
  35
  36 var tests = [
  37   {
  38     cookieName: "LCC_App0_BrowF_PrivF",
  39     originAttributes: new OriginAttributes(0),
  40   },
  41   {
  42     cookieName: "LCC_App1_BrowF_PrivF",
  43     originAttributes: new OriginAttributes(1),
  44   },
  45 ];
  46
  47 // test number: index into 'tests' array
  48 var i = 0;
  49
  50 function setupChannel(path) {
  51   var chan = NetUtil.newChannel({
  52     uri: URL + path,
  53     loadUsingSystemPrincipal: true,
  54   });
  55   chan.loadInfo.originAttributes = tests[i].originAttributes;
  56   chan.QueryInterface(Ci.nsIHttpChannel);
  57
  58   let loadGroup = Cc["@mozilla.org/network/load-group;1"].createInstance(
  59     Ci.nsILoadGroup
  60   );
  61
  62   if (chan.loadInfo.originAttributes.privateBrowsingId == 0) {
  63     loadGroup.notificationCallbacks = Cu.createLoadContext();
  64     chan.loadGroup = loadGroup;
  65
  66     chan.notificationCallbacks = Cu.createLoadContext();
  67   } else {
  68     loadGroup.notificationCallbacks = Cu.createPrivateLoadContext();
  69     chan.loadGroup = loadGroup;
  70
  71     chan.notificationCallbacks = Cu.createPrivateLoadContext();
  72   }
  73
  74   return chan;
  75 }
  76
  77 function setCookie() {
  78   var channel = setupChannel(cookieSetPath);
  79   channel.setRequestHeader("foo-set-cookie", tests[i].cookieName, false);
  80   channel.asyncOpen(new ChannelListener(setNextCookie, null));
  81 }
  82
  83 function setNextCookie() {
  84   if (++i == tests.length) {
  85     // all cookies set: switch to checking them
  86     i = 0;
  87     checkCookie();
  88   } else {
  89     info("setNextCookie:i=" + i);
  90     setCookie();
  91   }
  92 }
  93
  94 // Open channel that should send one and only one correct Cookie: header to
  95 // server, corresponding to it's namespace
  96 function checkCookie() {
  97   var channel = setupChannel(cookieCheckPath);
  98   channel.asyncOpen(new ChannelListener(completeCheckCookie, null));
  99 }
 100
 101 function completeCheckCookie(request) {
 102   // Look for all cookies in what the server saw: fail if we see any besides the
 103   // one expected cookie for each namespace;
 104   var expectedCookie = tests[i].cookieName;
 105   request.QueryInterface(Ci.nsIHttpChannel);
 106   var cookiesSeen = request.getResponseHeader("foo-saw-cookies");
 107
 108   var j;
 109   for (j = 0; j < tests.length; j++) {
 110     var cookieToCheck = tests[j].cookieName;
 111     let found = cookiesSeen.includes(cookieToCheck);
 112     if (found && expectedCookie != cookieToCheck) {
 113       do_throw(
 114         "test index " +
 115           i +
 116           ": found unexpected cookie '" +
 117           cookieToCheck +
 118           "': in '" +
 119           cookiesSeen +
 120           "'"
 121       );
 122     } else if (!found && expectedCookie == cookieToCheck) {
 123       do_throw(
 124         "test index " +
 125           i +
 126           ": missing expected cookie '" +
 127           expectedCookie +
 128           "': in '" +
 129           cookiesSeen +
 130           "'"
 131       );
 132     }
 133   }
 134   // If we get here we're good.
 135   info("Saw only correct cookie '" + expectedCookie + "'");
 136   Assert.ok(true);
 137
 138   if (++i == tests.length) {
 139     // end of tests
 140     httpserver.stop(do_test_finished);
 141   } else {
 142     checkCookie();
 143   }
 144 }
 145
 146 function run_test() {
 147   // Allow all cookies if the pref service is available in this process.
 148   if (!inChildProcess()) {
 149     Services.prefs.setIntPref("network.cookie.cookieBehavior", 0);
 150     Services.prefs.setBoolPref(
 151       "network.cookieJarSettings.unblocked_for_testing",
 152       true
 153     );
 154   }
 155
 156   httpserver.registerPathHandler(cookieSetPath, cookieSetHandler);
 157   httpserver.registerPathHandler(cookieCheckPath, cookieCheckHandler);
 158   httpserver.start(-1);
 159
 160   setCookie();
 161   do_test_pending();
 162 }
 163
 164 function cookieSetHandler(metadata, response) {
 165   var cookieName = metadata.getHeader("foo-set-cookie");
 166
 167   response.setStatusLine(metadata.httpVersion, 200, "Ok");
 168   response.setHeader("Set-Cookie", cookieName + "=1; Path=/", false);
 169   response.setHeader("Content-Type", "text/plain");
 170   response.bodyOutputStream.write("Ok", "Ok".length);
 171 }
 172
 173 function cookieCheckHandler(metadata, response) {
 174   var cookies = metadata.getHeader("Cookie");
 175
 176   response.setStatusLine(metadata.httpVersion, 200, "Ok");
 177   response.setHeader("foo-saw-cookies", cookies, false);
 178   response.setHeader("Content-Type", "text/plain");
 179   response.bodyOutputStream.write("Ok", "Ok".length);
 180 }