The Tor Browser: netwerk/test/unit/test_traceable

     1 // Test nsITraceableChannel interface.

     2 // Replace original listener with TracingListener that modifies body of HTTP

     3 // response. Make sure that body received by original channel's listener

     4 // is correctly modified.

     6 Cu.import("resource://testing-common/httpd.js");

     8 var httpserver = new HttpServer();

     9 httpserver.start(-1);

    10 const PORT = httpserver.identity.primaryPort;

    12 var pipe = null;

    13 var streamSink = null;

    15 var originalBody = "original http response body";

    16 var gotOnStartRequest = false;

    18 function TracingListener() {}

    20 TracingListener.prototype = {

    21   onStartRequest: function(request, context) {

    22     dump("*** tracing listener onStartRequest\n");

    24     gotOnStartRequest = true;

    26     request.QueryInterface(Components.interfaces.nsIHttpChannelInternal);

    28 // local/remote addresses broken in e10s: disable for now

    29 /*

    30     do_check_eq(request.localAddress, "127.0.0.1");

    31     do_check_eq(request.localPort > 0, true);

    32     do_check_neq(request.localPort, PORT);

    33     do_check_eq(request.remoteAddress, "127.0.0.1");

    34     do_check_eq(request.remotePort, PORT);

    35 */

    37     // Make sure listener can't be replaced after OnStartRequest was called.

    38     request.QueryInterface(Components.interfaces.nsITraceableChannel);

    39     try {

    40       var newListener = new TracingListener();

    41       newListener.listener = request.setNewListener(newListener);

    42     } catch(e) {

    43       dump("TracingListener.onStartRequest swallowing exception: " + e + "\n");

    44       return; // OK

    45     }

    46     do_throw("replaced channel's listener during onStartRequest.");

    47   },

    49   onStopRequest: function(request, context, statusCode) {

    50     dump("*** tracing listener onStopRequest\n");

    52     do_check_eq(gotOnStartRequest, true);

    54     try {

    55       var sin = Components.classes["@mozilla.org/scriptableinputstream;1"].

    56           createInstance(Ci.nsIScriptableInputStream);

    58       streamSink.close();

    59       var input = pipe.inputStream;

    60       sin.init(input);

    61       do_check_eq(sin.available(), originalBody.length);

    63       var result = sin.read(originalBody.length);

    64       do_check_eq(result, originalBody);

    66       input.close();

    67     } catch (e) {

    68       dump("TracingListener.onStopRequest swallowing exception: " + e + "\n");

    69     } finally {

    70       httpserver.stop(do_test_finished);

    71     }

    72   },

    74   QueryInterface: function(iid) {

    75     if (iid.equals(Components.interfaces.nsIRequestObserver) ||

    76         iid.equals(Components.interfaces.nsISupports)

    77         )

    78       return this;

    79     throw Components.results.NS_NOINTERFACE;

    80   },

    82   listener: null

    83 }

    86 function HttpResponseExaminer() {}

    88 HttpResponseExaminer.prototype = {

    89   register: function() {

    90     Cc["@mozilla.org/observer-service;1"].

    91       getService(Components.interfaces.nsIObserverService).

    92       addObserver(this, "http-on-examine-response", true);

    93     dump("Did HttpResponseExaminer.register\n");

    94   },

    96   // Replace channel's listener.

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

    98     dump("In HttpResponseExaminer.observe\n");

    99     try {

   100       subject.QueryInterface(Components.interfaces.nsITraceableChannel);

   102       var tee = Cc["@mozilla.org/network/stream-listener-tee;1"].

   103           createInstance(Ci.nsIStreamListenerTee);

   104       var newListener = new TracingListener();

   105       pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);

   106       pipe.init(false, false, 0, 0xffffffff, null);

   107       streamSink = pipe.outputStream;

   109       var originalListener = subject.setNewListener(tee);

   110       tee.init(originalListener, streamSink, newListener);

   111     } catch(e) {

   112       do_throw("can't replace listener " + e);

   113     }

   114     dump("Did HttpResponseExaminer.observe\n");

   115   },

   117   QueryInterface: function(iid) {

   118     if (iid.equals(Components.interfaces.nsIObserver) ||

   119         iid.equals(Components.interfaces.nsISupportsWeakReference) ||

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

   121       return this;

   122     throw Components.results.NS_NOINTERFACE;

   123   }

   124 }

   126 function test_handler(metadata, response) {

   127   response.setHeader("Content-Type", "text/html", false);

   128   response.setStatusLine(metadata.httpVersion, 200, "OK");

   129   response.bodyOutputStream.write(originalBody, originalBody.length);

   130 }

   132 function make_channel(url) {

   133   var ios = Cc["@mozilla.org/network/io-service;1"].

   134     getService(Ci.nsIIOService);

   135   return ios.newChannel(url, null, null).

   136     QueryInterface(Components.interfaces.nsIHttpChannel);

   137 }

   139 // Check if received body is correctly modified.

   140 function channel_finished(request, input, ctx) {

   141   httpserver.stop(do_test_finished);

   142 }

   144 function run_test() {

   145   var observer = new HttpResponseExaminer();

   146   observer.register();

   148   httpserver.registerPathHandler("/testdir", test_handler);

   150   var channel = make_channel("http://localhost:" + PORT + "/testdir");

   151   channel.asyncOpen(new ChannelListener(channel_finished), null);

   152   do_test_pending();

   153 }

The Tor Browser / file revision