The Tor Browser: netwerk/test/unit/test_protocolproxyservice.js@deefc01c0e14

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

     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 /* This Source Code Form is subject to the terms of the Mozilla Public

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

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

     7 // This testcase exercises the Protocol Proxy Service

     9 // These are the major sub tests:

    10 // run_filter_test();

    11 // run_filter_test2()

    12 // run_filter_test3()

    13 // run_pref_test();

    14 // run_pac_test();

    15 // run_pac_cancel_test();

    16 // run_proxy_host_filters_test();

    17 // run_myipaddress_test();

    18 // run_failed_script_test();

    19 // run_isresolvable_test();

    21 var ios = Components.classes["@mozilla.org/network/io-service;1"]

    22                     .getService(Components.interfaces.nsIIOService);

    23 var pps = Components.classes["@mozilla.org/network/protocol-proxy-service;1"]

    24                     .getService();

    25 var prefs = Components.classes["@mozilla.org/preferences-service;1"]

    26                      .getService(Components.interfaces.nsIPrefBranch);

    28 /**

    29  * Test nsIProtocolHandler that allows proxying, but doesn't allow HTTP

    30  * proxying.

    31  */

    32 function TestProtocolHandler() {

    33 }

    34 TestProtocolHandler.prototype = {

    35   QueryInterface: function(iid) {

    36     if (iid.equals(Components.interfaces.nsIProtocolHandler) ||

    37         iid.equals(Components.interfaces.nsISupports))

    38       return this;

    39     throw Components.results.NS_ERROR_NO_INTERFACE;

    40   },

    41   scheme: "moz-test",

    42   defaultPort: -1,

    43   protocolFlags: Components.interfaces.nsIProtocolHandler.URI_NOAUTH |

    44                  Components.interfaces.nsIProtocolHandler.URI_NORELATIVE |

    45                  Components.interfaces.nsIProtocolHandler.ALLOWS_PROXY |

    46                  Components.interfaces.nsIProtocolHandler.URI_DANGEROUS_TO_LOAD,

    47   newURI: function(spec, originCharset, baseURI) {

    48     var uri = Components.classes["@mozilla.org/network/simple-uri;1"]

    49                         .createInstance(Components.interfaces.nsIURI);

    50     uri.spec = spec;

    51     return uri;

    52   },

    53   newChannel: function(uri) {

    54     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;

    55   },

    56   allowPort: function(port, scheme) {

    57     return true;

    58   }

    59 };

    61 function TestProtocolHandlerFactory() {

    62 }

    63 TestProtocolHandlerFactory.prototype = {

    64   createInstance: function(delegate, iid) {

    65     return new TestProtocolHandler().QueryInterface(iid);

    66   },

    67   lockFactory: function(lock) {

    68   }

    69 };

    71 function register_test_protocol_handler() {

    72   var reg = Components.manager.QueryInterface(

    73       Components.interfaces.nsIComponentRegistrar);

    74   reg.registerFactory(Components.ID("{4ea7dd3a-8cae-499c-9f18-e1de773ca25b}"),

    75                       "TestProtocolHandler",

    76                       "@mozilla.org/network/protocol;1?name=moz-test",

    77                       new TestProtocolHandlerFactory());

    78 }

    80 function check_proxy(pi, type, host, port, flags, timeout, hasNext) {

    81   do_check_neq(pi, null);

    82   do_check_eq(pi.type, type);

    83   do_check_eq(pi.host, host);

    84   do_check_eq(pi.port, port);

    85   if (flags != -1)

    86     do_check_eq(pi.flags, flags);

    87   if (timeout != -1)

    88     do_check_eq(pi.failoverTimeout, timeout);

    89   if (hasNext)

    90     do_check_neq(pi.failoverProxy, null);

    91   else

    92     do_check_eq(pi.failoverProxy, null);

    93 }

    95 function TestFilter(type, host, port, flags, timeout) {

    96   this._type = type;

    97   this._host = host;

    98   this._port = port;

    99   this._flags = flags;

   100   this._timeout = timeout;

   101 }

   102 TestFilter.prototype = {

   103   _type: "",

   104   _host: "",

   105   _port: -1,

   106   _flags: 0,

   107   _timeout: 0,

   108   QueryInterface: function(iid) {

   109     if (iid.equals(Components.interfaces.nsIProtocolProxyFilter) ||

   110         iid.equals(Components.interfaces.nsISupports))

   111       return this;

   112     throw Components.results.NS_ERROR_NO_INTERFACE;

   113   },

   114   applyFilter: function(pps, uri, pi) {

   115     var pi_tail = pps.newProxyInfo(this._type, this._host, this._port,

   116                                    this._flags, this._timeout, null);

   117     if (pi)

   118       pi.failoverProxy = pi_tail;

   119     else

   120       pi = pi_tail;

   121     return pi;

   122   }

   123 };

   125 function BasicFilter() {}

   126 BasicFilter.prototype = {

   127   QueryInterface: function(iid) {

   128     if (iid.equals(Components.interfaces.nsIProtocolProxyFilter) ||

   129         iid.equals(Components.interfaces.nsISupports))

   130       return this;

   131     throw Components.results.NS_ERROR_NO_INTERFACE;

   132   },

   133   applyFilter: function(pps, uri, pi) {

   134     return pps.newProxyInfo("http", "localhost", 8080, 0, 10,

   135            pps.newProxyInfo("direct", "", -1, 0, 0, null));

   136   }

   137 };

   139 function resolveCallback() { }

   140 resolveCallback.prototype = {

   141   nextFunction: null,

   143   QueryInterface : function (iid) {

   144     const interfaces = [Components.interfaces.nsIProtocolProxyCallback,

   145                         Components.interfaces.nsISupports];

   146     if (!interfaces.some( function(v) { return iid.equals(v) } ))

   147       throw Components.results.NS_ERROR_NO_INTERFACE;

   148     return this;

   149   },

   151   onProxyAvailable : function (req, uri, pi, status) {

   152     this.nextFunction(pi);

   153   }

   154 };

   156 function run_filter_test() {

   157   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   159   // Verify initial state

   160   var cb = new resolveCallback();

   161   cb.nextFunction = filter_test0_1;

   162   var req = pps.asyncResolve(uri, 0, cb);

   163 }

   165 var filter01;

   166 var filter02;

   168 function filter_test0_1(pi) {

   169   do_check_eq(pi, null);

   171   // Push a filter and verify the results

   173   filter01 = new BasicFilter();

   174   filter02 = new BasicFilter();

   175   pps.registerFilter(filter01, 10);

   176   pps.registerFilter(filter02, 20);

   178   var cb = new resolveCallback();

   179   cb.nextFunction = filter_test0_2;

   180   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   181   var req = pps.asyncResolve(uri, 0, cb);

   182 }

   184 function filter_test0_2(pi)

   185 {

   186   check_proxy(pi, "http", "localhost", 8080, 0, 10, true);

   187   check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);

   189   pps.unregisterFilter(filter02);

   191   var cb = new resolveCallback();

   192   cb.nextFunction = filter_test0_3;

   193   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   194   var req = pps.asyncResolve(uri, 0, cb);

   195 }

   197 function filter_test0_3(pi)

   198 {

   199   check_proxy(pi, "http", "localhost", 8080, 0, 10, true);

   200   check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);

   202   // Remove filter and verify that we return to the initial state

   204   pps.unregisterFilter(filter01);

   206   var cb = new resolveCallback();

   207   cb.nextFunction = filter_test0_4;

   208   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   209   var req = pps.asyncResolve(uri, 0, cb);

   210 }

   212 function filter_test0_4(pi)

   213 {

   214   do_check_eq(pi, null);

   215   run_filter_test2();

   216 }

   218 var filter11;

   219 var filter12;

   221 function run_filter_test2() {

   222   // Push a filter and verify the results

   224   filter11 = new TestFilter("http", "foo", 8080, 0, 10);

   225   filter12 = new TestFilter("http", "bar", 8090, 0, 10);

   226   pps.registerFilter(filter11, 20);

   227   pps.registerFilter(filter12, 10);

   229   var cb = new resolveCallback();

   230   cb.nextFunction = filter_test1_1;

   231   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   232   var req = pps.asyncResolve(uri, 0, cb);

   233 }

   235 function filter_test1_1(pi) {

   236   check_proxy(pi, "http", "bar", 8090, 0, 10, true);

   237   check_proxy(pi.failoverProxy, "http", "foo", 8080, 0, 10, false);

   239   pps.unregisterFilter(filter12);

   241   var cb = new resolveCallback();

   242   cb.nextFunction = filter_test1_2;

   243   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   244   var req = pps.asyncResolve(uri, 0, cb);

   245 }

   247 function filter_test1_2(pi) {

   248   check_proxy(pi, "http", "foo", 8080, 0, 10, false);

   250   // Remove filter and verify that we return to the initial state

   252   pps.unregisterFilter(filter11);

   254   var cb = new resolveCallback();

   255   cb.nextFunction = filter_test1_3;

   256   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   257   var req = pps.asyncResolve(uri, 0, cb);

   258 }

   260 function filter_test1_3(pi) {

   261   do_check_eq(pi, null);

   262   run_filter_test3();

   263 }

   265 var filter_3_1;

   267 function run_filter_test3() {

   268   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   270   // Push a filter and verify the results asynchronously

   272   filter_3_1 = new TestFilter("http", "foo", 8080, 0, 10);

   273   pps.registerFilter(filter_3_1, 20);

   275   var cb = new resolveCallback();

   276   cb.nextFunction = filter_test3_1;

   277   var req = pps.asyncResolve(uri, 0, cb);

   278 }

   280 function filter_test3_1(pi) {

   281   check_proxy(pi, "http", "foo", 8080, 0, 10, false);

   282   pps.unregisterFilter(filter_3_1);

   283   run_pref_test();

   284 }

   286 function run_pref_test() {

   287   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   289   // Verify 'direct' setting

   291   prefs.setIntPref("network.proxy.type", 0);

   293   var cb = new resolveCallback();

   294   cb.nextFunction = pref_test1_1;

   295   var req = pps.asyncResolve(uri, 0, cb);

   296 }

   298 function pref_test1_1(pi)

   299 {

   300   do_check_eq(pi, null);

   302   // Verify 'manual' setting

   303   prefs.setIntPref("network.proxy.type", 1);

   305   var cb = new resolveCallback();

   306   cb.nextFunction = pref_test1_2;

   307   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   308   var req = pps.asyncResolve(uri, 0, cb);

   309 }

   311 function pref_test1_2(pi)

   312 {

   313   // nothing yet configured

   314   do_check_eq(pi, null);

   316   // try HTTP configuration

   317   prefs.setCharPref("network.proxy.http", "foopy");

   318   prefs.setIntPref("network.proxy.http_port", 8080);

   320   var cb = new resolveCallback();

   321   cb.nextFunction = pref_test1_3;

   322   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   323   var req = pps.asyncResolve(uri, 0, cb);

   324 }

   326 function pref_test1_3(pi)

   327 {

   328   check_proxy(pi, "http", "foopy", 8080, 0, -1, false);

   330   prefs.setCharPref("network.proxy.http", "");

   331   prefs.setIntPref("network.proxy.http_port", 0);

   333   // try SOCKS configuration

   334   prefs.setCharPref("network.proxy.socks", "barbar");

   335   prefs.setIntPref("network.proxy.socks_port", 1203);

   337   var cb = new resolveCallback();

   338   cb.nextFunction = pref_test1_4;

   339   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   340   var req = pps.asyncResolve(uri, 0, cb);

   341 }

   343 function pref_test1_4(pi)

   344 {

   345   check_proxy(pi, "socks", "barbar", 1203, 0, -1, false);

   346   run_pac_test();

   347 }

   349 function run_protocol_handler_test() {

   350   var uri = ios.newURI("moz-test:foopy", null, null);

   352   var cb = new resolveCallback();

   353   cb.nextFunction = protocol_handler_test_1;

   354   var req = pps.asyncResolve(uri, 0, cb);

   355 }

   357 function protocol_handler_test_1(pi)

   358 {

   359   do_check_eq(pi, null);

   360   prefs.setCharPref("network.proxy.autoconfig_url", "");

   361   prefs.setIntPref("network.proxy.type", 0);

   363   run_pac_cancel_test();

   364 }

   366 function TestResolveCallback() {

   367 }

   368 TestResolveCallback.prototype = {

   369   QueryInterface:

   370   function TestResolveCallback_QueryInterface(iid) {

   371     if (iid.equals(Components.interfaces.nsIProtocolProxyCallback) ||

   372         iid.equals(Components.interfaces.nsISupports))

   373       return this;

   374     throw Components.results.NS_ERROR_NO_INTERFACE;

   375   },

   377   onProxyAvailable:

   378   function TestResolveCallback_onProxyAvailable(req, uri, pi, status) {

   379     dump("*** uri=" + uri.spec + ", status=" + status + "\n");

   381     do_check_neq(req, null);

   382     do_check_neq(uri, null);

   383     do_check_eq(status, 0);

   384     do_check_neq(pi, null);

   386     check_proxy(pi, "http", "foopy", 8080, 0, -1, true);

   387     check_proxy(pi.failoverProxy, "direct", "", -1, -1, -1, false);

   389     run_protocol_handler_test();

   390   }

   391 };

   393 function run_pac_test() {

   394   var pac = 'data:text/plain,' +

   395             'function FindProxyForURL(url, host) {' +

   396             '  return "PROXY foopy:8080; DIRECT";' +

   397             '}';

   398   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   400   // Configure PAC

   402   prefs.setIntPref("network.proxy.type", 2);

   403   prefs.setCharPref("network.proxy.autoconfig_url", pac);

   405   var req = pps.asyncResolve(uri, 0, new TestResolveCallback());

   406 }

   408 function TestResolveCancelationCallback() {

   409 }

   410 TestResolveCancelationCallback.prototype = {

   411   QueryInterface:

   412   function TestResolveCallback_QueryInterface(iid) {

   413     if (iid.equals(Components.interfaces.nsIProtocolProxyCallback) ||

   414         iid.equals(Components.interfaces.nsISupports))

   415       return this;

   416     throw Components.results.NS_ERROR_NO_INTERFACE;

   417   },

   419   onProxyAvailable:

   420   function TestResolveCancelationCallback_onProxyAvailable(req, uri, pi, status) {

   421     dump("*** uri=" + uri.spec + ", status=" + status + "\n");

   423     do_check_neq(req, null);

   424     do_check_neq(uri, null);

   425     do_check_eq(status, Components.results.NS_ERROR_ABORT);

   426     do_check_eq(pi, null);

   428     prefs.setCharPref("network.proxy.autoconfig_url", "");

   429     prefs.setIntPref("network.proxy.type", 0);

   431     run_proxy_host_filters_test();

   432   }

   433 };

   435 function run_pac_cancel_test() {

   436   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   438   // Configure PAC

   439   var pac = 'data:text/plain,' +

   440             'function FindProxyForURL(url, host) {' +

   441             '  return "PROXY foopy:8080; DIRECT";' +

   442             '}';

   443   prefs.setIntPref("network.proxy.type", 2);

   444   prefs.setCharPref("network.proxy.autoconfig_url", pac);

   446   var req = pps.asyncResolve(uri, 0, new TestResolveCancelationCallback());

   447   req.cancel(Components.results.NS_ERROR_ABORT);

   448 }

   450 var hostList;

   451 var hostIDX;

   452 var bShouldBeFiltered;

   453 var hostNextFX;

   455 function check_host_filters(hl, shouldBe, nextFX) {

   456   hostList = hl;

   457   hostIDX = 0;

   458   bShouldBeFiltered = shouldBe;

   459   hostNextFX = nextFX;

   461   if (hostList.length > hostIDX)

   462     check_host_filter(hostIDX);

   463 }

   465 function check_host_filters_cb()

   466 {

   467   hostIDX++;

   468   if (hostList.length > hostIDX)

   469     check_host_filter(hostIDX);

   470   else

   471     hostNextFX();

   472 }

   474 function check_host_filter(i) {

   475   var uri;

   476   dump("*** uri=" + hostList[i] + " bShouldBeFiltered=" + bShouldBeFiltered + "\n");

   477   uri = ios.newURI(hostList[i], null, null);

   479   var cb = new resolveCallback();

   480   cb.nextFunction = host_filter_cb;

   481   var req = pps.asyncResolve(uri, 0, cb);

   482 }

   484 function host_filter_cb(proxy)

   485 {

   486   if (bShouldBeFiltered) {

   487     do_check_eq(proxy, null);

   488   } else {

   489     do_check_neq(proxy, null);

   490     // Just to be sure, let's check that the proxy is correct

   491     // - this should match the proxy setup in the calling function

   492     check_proxy(proxy, "http", "foopy", 8080, 0, -1, false);

   493   }

   494   check_host_filters_cb();

   495 }

   498 // Verify that hists in the host filter list are not proxied

   499 // refers to "network.proxy.no_proxies_on"

   501 var uriStrUseProxyList;

   502 var uriStrUseProxyList;

   503 var hostFilterList;

   505 function run_proxy_host_filters_test() {

   506   // Get prefs object from DOM

   507   // Setup a basic HTTP proxy configuration

   508   // - pps.resolve() needs this to return proxy info for non-filtered hosts

   509   prefs.setIntPref("network.proxy.type", 1);

   510   prefs.setCharPref("network.proxy.http", "foopy");

   511   prefs.setIntPref("network.proxy.http_port", 8080);

   513   // Setup host filter list string for "no_proxies_on"

   514   hostFilterList = "www.mozilla.org, www.google.com, www.apple.com, "

   515                        + ".domain, .domain2.org"

   516   prefs.setCharPref("network.proxy.no_proxies_on", hostFilterList);

   517   do_check_eq(prefs.getCharPref("network.proxy.no_proxies_on"), hostFilterList);

   519   var rv;

   520   // Check the hosts that should be filtered out

   521   uriStrFilterList = [ "http://www.mozilla.org/",

   522                            "http://www.google.com/",

   523                            "http://www.apple.com/",

   524                            "http://somehost.domain/",

   525                            "http://someotherhost.domain/",

   526                            "http://somehost.domain2.org/",

   527                            "http://somehost.subdomain.domain2.org/" ];

   528   check_host_filters(uriStrFilterList, true, host_filters_1);

   529 }

   531 function host_filters_1()

   532 {

   533   // Check the hosts that should be proxied

   534   uriStrUseProxyList = [ "http://www.mozilla.com/",

   535                              "http://mail.google.com/",

   536                              "http://somehost.domain.co.uk/",

   537                              "http://somelocalhost/" ];

   538   check_host_filters(uriStrUseProxyList, false, host_filters_2);

   539 }

   541 function host_filters_2()

   542 {

   543   // Set no_proxies_on to include local hosts

   544   prefs.setCharPref("network.proxy.no_proxies_on", hostFilterList + ", <local>");

   545   do_check_eq(prefs.getCharPref("network.proxy.no_proxies_on"),

   546               hostFilterList + ", <local>");

   547   // Amend lists - move local domain to filtered list

   548   uriStrFilterList.push(uriStrUseProxyList.pop());

   549   check_host_filters(uriStrFilterList, true, host_filters_3);

   550 }

   552 function host_filters_3()

   553 {

   554   check_host_filters(uriStrUseProxyList, false, host_filters_4);

   555 }

   557 function host_filters_4()

   558 {

   559   // Cleanup

   560   prefs.setCharPref("network.proxy.no_proxies_on", "");

   561   do_check_eq(prefs.getCharPref("network.proxy.no_proxies_on"), "");

   563   run_myipaddress_test();

   564 }

   566 function run_myipaddress_test()

   567 {

   568   // This test makes sure myIpAddress() comes up with some valid

   569   // IP address other than localhost. The DUT must be configured with

   570   // an Internet route for this to work - though no Internet traffic

   571   // should be created.

   573   var pac = 'data:text/plain,' +

   574             'function FindProxyForURL(url, host) {' +

   575             ' return "PROXY " + myIpAddress() + ":1234";' +

   576             '}';

   578   // no traffic to this IP is ever sent, it is just a public IP that

   579   // does not require DNS to determine a route.

   580   var uri = ios.newURI("http://192.0.43.10/", null, null);

   582   prefs.setIntPref("network.proxy.type", 2);

   583   prefs.setCharPref("network.proxy.autoconfig_url", pac);

   585   var cb = new resolveCallback();

   586   cb.nextFunction = myipaddress_callback;

   587   var req = pps.asyncResolve(uri, 0, cb);

   588 }

   590 function myipaddress_callback(pi)

   591 {

   592   do_check_neq(pi, null);

   593   do_check_eq(pi.type, "http");

   594   do_check_eq(pi.port, 1234);

   596   // make sure we didn't return localhost

   597   do_check_neq(pi.host, null);

   598   do_check_neq(pi.host, "127.0.0.1");

   599   do_check_neq(pi.host, "::1");

   601   run_myipaddress_test_2();

   602 }

   604 function run_myipaddress_test_2()

   605 {

   606   // test that myIPAddress() can be used outside of the scope of

   607   // FindProxyForURL(). bug 829646.

   609   var pac = 'data:text/plain,' +

   610             'var myaddr = myIpAddress(); ' +

   611             'function FindProxyForURL(url, host) {' +

   612             ' return "PROXY " + myaddr + ":5678";' +

   613             '}';

   615   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   616   prefs.setIntPref("network.proxy.type", 2);

   617   prefs.setCharPref("network.proxy.autoconfig_url", pac);

   619   var cb = new resolveCallback();

   620   cb.nextFunction = myipaddress2_callback;

   621   var req = pps.asyncResolve(uri, 0, cb);

   622 }

   624 function myipaddress2_callback(pi)

   625 {

   626   do_check_neq(pi, null);

   627   do_check_eq(pi.type, "http");

   628   do_check_eq(pi.port, 5678);

   630   // make sure we didn't return localhost

   631   do_check_neq(pi.host, null);

   632   do_check_neq(pi.host, "127.0.0.1");

   633   do_check_neq(pi.host, "::1");

   635   run_failed_script_test();

   636 }

   638 function run_failed_script_test()

   639 {

   640   // test to make sure we go direct with invalid PAC

   641   var pac = 'data:text/plain,' +

   642             '\nfor(;\n';

   644   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   646   prefs.setIntPref("network.proxy.type", 2);

   647   prefs.setCharPref("network.proxy.autoconfig_url", pac);

   649   var cb = new resolveCallback();

   650   cb.nextFunction = failed_script_callback;

   651   var req = pps.asyncResolve(uri, 0, cb);

   652 }

   654 var directFilter;

   656 function failed_script_callback(pi)

   657 {

   658   // we should go direct

   659   do_check_eq(pi, null);

   661   // test that we honor filters when configured to go direct

   662   prefs.setIntPref("network.proxy.type", 0);

   663   directFilter = new TestFilter("http", "127.0.0.1", 7246, 0, 0);

   664   pps.registerFilter(directFilter, 10);

   666   // test that on-modify-request contains the proxy info too

   667   var obs = Components.classes["@mozilla.org/observer-service;1"].getService();

   668   obs = obs.QueryInterface(Components.interfaces.nsIObserverService);

   669   obs.addObserver(directFilterListener, "http-on-modify-request", false);

   671   var chan = ios.newChannel("http://127.0.0.1:7247", "", null);

   672   chan.asyncOpen(directFilterListener, chan);

   673 }

   675 var directFilterListener = {

   676   onModifyRequestCalled : false,

   678   onStartRequest: function test_onStart(request, ctx) {  },

   679   onDataAvailable: function test_OnData() { },

   681   onStopRequest: function test_onStop(request, ctx, status) {

   682     // check on the PI from the channel itself

   683     ctx.QueryInterface(Components.interfaces.nsIProxiedChannel);

   684     check_proxy(ctx.proxyInfo, "http", "127.0.0.1", 7246, 0, 0, false);

   685     pps.unregisterFilter(directFilter);

   687     // check on the PI from on-modify-request

   688     do_check_true(this.onModifyRequestCalled);

   689     var obs = Components.classes["@mozilla.org/observer-service;1"].getService();

   690     obs = obs.QueryInterface(Components.interfaces.nsIObserverService);

   691     obs.removeObserver(this, "http-on-modify-request");

   693     run_isresolvable_test();

   694   },

   696    observe: function(subject, topic, data) {

   697      if (topic === "http-on-modify-request" &&

   698          subject instanceof Components.interfaces.nsIHttpChannel &&

   699          subject instanceof Components.interfaces.nsIProxiedChannel) {

   700        check_proxy(subject.proxyInfo, "http", "127.0.0.1", 7246, 0, 0, false);

   701        this.onModifyRequestCalled = true;

   702      }

   703    }

   704 };

   706 function run_isresolvable_test()

   707 {

   708   // test a non resolvable host in the pac file

   710   var pac = 'data:text/plain,' +

   711             'function FindProxyForURL(url, host) {' +

   712             ' if (isResolvable("nonexistant.lan"))' +

   713             '   return "DIRECT";' +

   714             ' return "PROXY 127.0.0.1:1234";' +

   715             '}';

   717   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   719   prefs.setIntPref("network.proxy.type", 2);

   720   prefs.setCharPref("network.proxy.autoconfig_url", pac);

   722   var cb = new resolveCallback();

   723   cb.nextFunction = isresolvable_callback;

   724   var req = pps.asyncResolve(uri, 0, cb);

   725 }

   727 function isresolvable_callback(pi)

   728 {

   729   do_check_neq(pi, null);

   730   do_check_eq(pi.type, "http");

   731   do_check_eq(pi.port, 1234);

   732   do_check_eq(pi.host, "127.0.0.1");

   734   prefs.setIntPref("network.proxy.type", 0);

   735   do_test_finished();

   736 }

   738 function run_deprecated_sync_test()

   739 {

   740   var uri = ios.newURI("http://www.mozilla.org/", null, null);

   742   pps.QueryInterface(Components.interfaces.nsIProtocolProxyService2);

   744   // Verify initial state

   745   var pi = pps.deprecatedBlockingResolve(uri, 0);

   746   do_check_eq(pi, null);

   748   // Push a filter and verify the results

   749   var filter1 = new BasicFilter();

   750   var filter2 = new BasicFilter();

   751   pps.registerFilter(filter1, 10);

   752   pps.registerFilter(filter2, 20);

   754   pi = pps.deprecatedBlockingResolve(uri, 0);

   755   check_proxy(pi, "http", "localhost", 8080, 0, 10, true);

   756   check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);

   758   pps.unregisterFilter(filter2);

   759   pi = pps.deprecatedBlockingResolve(uri, 0);

   760   check_proxy(pi, "http", "localhost", 8080, 0, 10, true);

   761   check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);

   763   // Remove filter and verify that we return to the initial state

   764   pps.unregisterFilter(filter1);

   765   pi = pps.deprecatedBlockingResolve(uri, 0);

   766   do_check_eq(pi, null);

   767 }

   769 function run_test() {

   770   register_test_protocol_handler();

   772   // any synchronous tests

   773   run_deprecated_sync_test();

   775   // start of asynchronous test chain

   776   run_filter_test();

   777   do_test_pending();

   778 }

The Tor Browser / file revision

netwerk/test/unit/test_protocolproxyservice.js@deefc01c0e14

netwerk/test/unit/test_protocolproxyservice.js