netwerk/test/unit/test_protocolproxyservice.js

   1 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et: */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is mozilla.org code.
  17  *
  18  * The Initial Developer of the Original Code is Google Inc.
  19  * Portions created by the Initial Developer are Copyright (C) 2005
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *  Darin Fisher <darin@meer.net>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 // This testcase exercises the Protocol Proxy Service
  40
  41 var ios = Components.classes["@mozilla.org/network/io-service;1"]
  42                     .getService(Components.interfaces.nsIIOService);
  43 var pps = Components.classes["@mozilla.org/network/protocol-proxy-service;1"]
  44                     .getService();
  45
  46 /**
  47  * Test nsIProtocolHandler that allows proxying, but doesn't allow HTTP
  48  * proxying.
  49  */
  50 function TestProtocolHandler() {
  51 }
  52 TestProtocolHandler.prototype = {
  53   QueryInterface: function(iid) {
  54     if (iid.equals(Components.interfaces.nsIProtocolHandler) ||
  55         iid.equals(Components.interfaces.nsISupports))
  56       return this;
  57     throw Components.results.NS_ERROR_NO_INTERFACE;
  58   },
  59   scheme: "moz-test",
  60   defaultPort: -1,
  61   protocolFlags: Components.interfaces.nsIProtocolHandler.URI_NOAUTH |
  62                  Components.interfaces.nsIProtocolHandler.URI_NORELATIVE |
  63                  Components.interfaces.nsIProtocolHandler.ALLOWS_PROXY |
  64                  Components.interfaces.nsIProtocolHandler.URI_DANGEROUS_TO_LOAD,
  65   newURI: function(spec, originCharset, baseURI) {
  66     var uri = Components.classes["@mozilla.org/network/simple-uri;1"]
  67                         .createInstance(Components.interfaces.nsIURI);
  68     uri.spec = spec;
  69     return uri;
  70   },
  71   newChannel: function(uri) {
  72     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  73   },
  74   allowPort: function(port, scheme) {
  75     return true;
  76   }
  77 };
  78
  79 function TestProtocolHandlerFactory() {
  80 }
  81 TestProtocolHandlerFactory.prototype = {
  82   createInstance: function(delegate, iid) {
  83     return new TestProtocolHandler().QueryInterface(iid);
  84   },
  85   lockFactory: function(lock) {
  86   }
  87 };
  88
  89 function register_test_protocol_handler() {
  90   var reg = Components.manager.QueryInterface(
  91       Components.interfaces.nsIComponentRegistrar);
  92   reg.registerFactory(Components.ID("{4ea7dd3a-8cae-499c-9f18-e1de773ca25b}"),
  93                       "TestProtocolHandler",
  94                       "@mozilla.org/network/protocol;1?name=moz-test",
  95                       new TestProtocolHandlerFactory());
  96 }
  97
  98 function check_proxy(pi, type, host, port, flags, timeout, hasNext) {
  99   do_check_neq(pi, null);
 100   do_check_eq(pi.type, type);
 101   do_check_eq(pi.host, host);
 102   do_check_eq(pi.port, port);
 103   if (flags != -1)
 104     do_check_eq(pi.flags, flags);
 105   if (timeout != -1)
 106     do_check_eq(pi.failoverTimeout, timeout);
 107   if (hasNext)
 108     do_check_neq(pi.failoverProxy, null);
 109   else
 110     do_check_eq(pi.failoverProxy, null);
 111 }
 112
 113 function TestFilter(type, host, port, flags, timeout) {
 114   this._type = type;
 115   this._host = host;
 116   this._port = port;
 117   this._flags = flags;
 118   this._timeout = timeout;
 119 }
 120 TestFilter.prototype = {
 121   _type: "",
 122   _host: "",
 123   _port: -1,
 124   _flags: 0,
 125   _timeout: 0,
 126   QueryInterface: function(iid) {
 127     if (iid.equals(Components.interfaces.nsIProtocolProxyFilter) ||
 128         iid.equals(Components.interfaces.nsISupports))
 129       return this;
 130     throw Components.results.NS_ERROR_NO_INTERFACE;
 131   },
 132   applyFilter: function(pps, uri, pi) {
 133     var pi_tail = pps.newProxyInfo(this._type, this._host, this._port,
 134                                    this._flags, this._timeout, null);
 135     if (pi)
 136       pi.failoverProxy = pi_tail;
 137     else
 138       pi = pi_tail;
 139     return pi;
 140   }
 141 };
 142
 143 function BasicFilter() {}
 144 BasicFilter.prototype = {
 145   QueryInterface: function(iid) {
 146     if (iid.equals(Components.interfaces.nsIProtocolProxyFilter) ||
 147         iid.equals(Components.interfaces.nsISupports))
 148       return this;
 149     throw Components.results.NS_ERROR_NO_INTERFACE;
 150   },
 151   applyFilter: function(pps, uri, pi) {
 152     return pps.newProxyInfo("http", "localhost", 8080, 0, 10,
 153            pps.newProxyInfo("direct", "", -1, 0, 0, null));
 154   }
 155 };
 156
 157 function run_filter_test() {
 158   var uri = ios.newURI("http://www.mozilla.org/", null, null);
 159
 160   // Verify initial state
 161
 162   var pi = pps.resolve(uri, 0);
 163   do_check_eq(pi, null);
 164
 165   // Push a filter and verify the results
 166
 167   var filter1 = new BasicFilter();
 168   var filter2 = new BasicFilter();
 169   pps.registerFilter(filter1, 10);
 170   pps.registerFilter(filter2, 20);
 171
 172   pi = pps.resolve(uri, 0);
 173   check_proxy(pi, "http", "localhost", 8080, 0, 10, true);
 174   check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);
 175
 176   pps.unregisterFilter(filter2);
 177   pi = pps.resolve(uri, 0);
 178   check_proxy(pi, "http", "localhost", 8080, 0, 10, true);
 179   check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);
 180
 181   // Remove filter and verify that we return to the initial state
 182
 183   pps.unregisterFilter(filter1);
 184   pi = pps.resolve(uri, 0);
 185   do_check_eq(pi, null);
 186 }
 187
 188 function run_filter_test2() {
 189   var uri = ios.newURI("http://www.mozilla.org/", null, null);
 190
 191   // Verify initial state
 192
 193   var pi = pps.resolve(uri, 0);
 194   do_check_eq(pi, null);
 195
 196   // Push a filter and verify the results
 197
 198   var filter1 = new TestFilter("http", "foo", 8080, 0, 10);
 199   var filter2 = new TestFilter("http", "bar", 8090, 0, 10);
 200   pps.registerFilter(filter1, 20);
 201   pps.registerFilter(filter2, 10);
 202
 203   pi = pps.resolve(uri, 0);
 204   check_proxy(pi, "http", "bar", 8090, 0, 10, true);
 205   check_proxy(pi.failoverProxy, "http", "foo", 8080, 0, 10, false);
 206
 207   pps.unregisterFilter(filter2);
 208   pi = pps.resolve(uri, 0);
 209   check_proxy(pi, "http", "foo", 8080, 0, 10, false);
 210
 211   // Remove filter and verify that we return to the initial state
 212
 213   pps.unregisterFilter(filter1);
 214   pi = pps.resolve(uri, 0);
 215   do_check_eq(pi, null);
 216 }
 217
 218 function run_pref_test() {
 219   var uri = ios.newURI("http://www.mozilla.org/", null, null);
 220
 221   var prefs = Components.classes["@mozilla.org/preferences-service;1"]
 222                         .getService(Components.interfaces.nsIPrefBranch);
 223
 224   // Verify 'direct' setting
 225
 226   prefs.setIntPref("network.proxy.type", 0);
 227
 228   var pi = pps.resolve(uri, 0);
 229   do_check_eq(pi, null);
 230
 231   // Verify 'manual' setting
 232
 233   prefs.setIntPref("network.proxy.type", 1);
 234
 235   // nothing yet configured
 236   pi = pps.resolve(uri, 0);
 237   do_check_eq(pi, null);
 238
 239   // try HTTP configuration
 240   prefs.setCharPref("network.proxy.http", "foopy");
 241   prefs.setIntPref("network.proxy.http_port", 8080);
 242
 243   pi = pps.resolve(uri, 0);
 244   check_proxy(pi, "http", "foopy", 8080, 0, -1, false);
 245
 246   prefs.setCharPref("network.proxy.http", "");
 247   prefs.setIntPref("network.proxy.http_port", 0);
 248
 249   // try SOCKS configuration
 250   prefs.setCharPref("network.proxy.socks", "barbar");
 251   prefs.setIntPref("network.proxy.socks_port", 1203);
 252
 253   pi = pps.resolve(uri, 0);
 254   check_proxy(pi, "socks", "barbar", 1203, 0, -1, false);
 255 }
 256
 257 function run_protocol_handler_test() {
 258   var uri = ios.newURI("moz-test:foopy", null, null);
 259
 260   var pi = pps.resolve(uri, 0);
 261   do_check_eq(pi, null);
 262 }
 263
 264 function TestResolveCallback() {
 265 }
 266 TestResolveCallback.prototype = {
 267   QueryInterface:
 268   function TestResolveCallback_QueryInterface(iid) {
 269     if (iid.equals(Components.interfaces.nsIProtocolProxyCallback) ||
 270         iid.equals(Components.interfaces.nsISupports))
 271       return this;
 272     throw Components.results.NS_ERROR_NO_INTERFACE;
 273   },
 274
 275   onProxyAvailable:
 276   function TestResolveCallback_onProxyAvailable(req, uri, pi, status) {
 277     dump("*** uri=" + uri.spec + ", status=" + status + "\n");
 278
 279     do_check_neq(req, null);
 280     do_check_neq(uri, null);
 281     do_check_eq(status, 0);
 282     do_check_neq(pi, null);
 283
 284     check_proxy(pi, "http", "foopy", 8080, 0, -1, true);
 285     check_proxy(pi.failoverProxy, "direct", "", -1, -1, -1, false);
 286
 287     // verify direct query now that we know the PAC file is loaded
 288     pi = pps.resolve(ios.newURI("http://bazbat.com/", null, null), 0);
 289     do_check_neq(pi, null);
 290     check_proxy(pi, "http", "foopy", 8080, 0, -1, true);
 291     check_proxy(pi.failoverProxy, "direct", "", -1, -1, -1, false);
 292
 293     run_protocol_handler_test();
 294
 295     var prefs = Components.classes["@mozilla.org/preferences-service;1"]
 296                           .getService(Components.interfaces.nsIPrefBranch);
 297     prefs.setCharPref("network.proxy.autoconfig_url", "");
 298     prefs.setIntPref("network.proxy.type", 0);
 299
 300     run_test_continued();
 301     do_test_finished();
 302   }
 303 };
 304
 305 function run_pac_test() {
 306   var pac = 'data:text/plain,' +
 307             'function FindProxyForURL(url, host) {' +
 308             '  return "PROXY foopy:8080; DIRECT";' +
 309             '}';
 310   var uri = ios.newURI("http://www.mozilla.org/", null, null);
 311
 312   var prefs = Components.classes["@mozilla.org/preferences-service;1"]
 313                         .getService(Components.interfaces.nsIPrefBranch);
 314
 315   // Configure PAC
 316
 317   prefs.setIntPref("network.proxy.type", 2);
 318   prefs.setCharPref("network.proxy.autoconfig_url", pac);
 319
 320   // Test it out (we expect an "unknown" result since the PAC load is async)
 321   var pi = pps.resolve(uri, 0);
 322   do_check_neq(pi, null);
 323   do_check_eq(pi.type, "unknown");
 324
 325   // We expect the NON_BLOCKING flag to trigger an exception here since
 326   // we have configured the PPS to use PAC.
 327   var hit_exception = false;
 328   try {
 329     pps.resolve(uri, pps.RESOLVE_NON_BLOCKING);
 330   } catch (e) {
 331     hit_exception = true;
 332   }
 333   do_check_eq(hit_exception, true);
 334
 335   var req = pps.asyncResolve(uri, 0, new TestResolveCallback());
 336   do_test_pending();
 337 }
 338
 339 function TestResolveCancelationCallback() {
 340 }
 341 TestResolveCancelationCallback.prototype = {
 342   QueryInterface:
 343   function TestResolveCallback_QueryInterface(iid) {
 344     if (iid.equals(Components.interfaces.nsIProtocolProxyCallback) ||
 345         iid.equals(Components.interfaces.nsISupports))
 346       return this;
 347     throw Components.results.NS_ERROR_NO_INTERFACE;
 348   },
 349
 350   onProxyAvailable:
 351   function TestResolveCancelationCallback_onProxyAvailable(req, uri, pi, status) {
 352     dump("*** uri=" + uri.spec + ", status=" + status + "\n");
 353
 354     do_check_neq(req, null);
 355     do_check_neq(uri, null);
 356     do_check_eq(status, Components.results.NS_ERROR_ABORT);
 357     do_check_eq(pi, null);
 358
 359     var prefs = Components.classes["@mozilla.org/preferences-service;1"]
 360                           .getService(Components.interfaces.nsIPrefBranch);
 361     prefs.setCharPref("network.proxy.autoconfig_url", "");
 362     prefs.setIntPref("network.proxy.type", 0);
 363
 364     run_test_continued_2();
 365     do_test_finished();
 366   }
 367 };
 368
 369 function run_pac_cancel_test() {
 370   var uri = ios.newURI("http://www.mozilla.org/", null, null);
 371
 372   // Configure PAC
 373   var pac = 'data:text/plain,' +
 374             'function FindProxyForURL(url, host) {' +
 375             '  return "PROXY foopy:8080; DIRECT";' +
 376             '}';
 377   var prefs = Components.classes["@mozilla.org/preferences-service;1"]
 378                         .getService(Components.interfaces.nsIPrefBranch);
 379   prefs.setIntPref("network.proxy.type", 2);
 380   prefs.setCharPref("network.proxy.autoconfig_url", pac);
 381
 382   var req = pps.asyncResolve(uri, 0, new TestResolveCancelationCallback());
 383   req.cancel(Components.results.NS_ERROR_ABORT);
 384   do_test_pending();
 385 }
 386
 387 function run_test() {
 388   register_test_protocol_handler();
 389   run_filter_test();
 390   run_filter_test2();
 391   run_pref_test();
 392   run_pac_test();
 393   // additional tests may be added to run_test_continued
 394 }
 395
 396 function run_test_continued() {
 397   run_pac_cancel_test();
 398   // additional tests may be added to run_test_continued_2
 399 }
 400
 401 function run_test_continued_2() {
 402 }