The Tor Browser: toolkit/devtools/webconsole/test/test_network

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 <!DOCTYPE HTML>

     2 <html lang="en">

     3 <head>

     4   <meta charset="utf8">

     5   <title>Test for the network actor (POST request)</title>

     6   <script type="text/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>

     7   <script type="text/javascript;version=1.8" src="common.js"></script>

     8   <!-- Any copyright is dedicated to the Public Domain.

     9      - http://creativecommons.org/publicdomain/zero/1.0/ -->

    10 </head>

    11 <body>

    12 <p>Test for the network actor (POST request)</p>

    14 <iframe src="http://example.com/chrome/toolkit/devtools/webconsole/test/network_requests_iframe.html"></iframe>

    16 <script class="testbody" type="text/javascript;version=1.8">

    17 SimpleTest.waitForExplicitFinish();

    19 function startTest()

    20 {

    21   removeEventListener("load", startTest);

    23   attachConsole(["NetworkActivity"], onAttach, true);

    24 }

    26 function onAttach(aState, aResponse)

    27 {

    28   info("enable network request and response body logging");

    30   onSetPreferences = onSetPreferences.bind(null, aState);

    31   aState.client.setPreferences({

    32     "NetworkMonitor.saveRequestAndResponseBodies": true,

    33   }, onSetPreferences);

    34 }

    36 function onSetPreferences(aState, aResponse)

    37 {

    38   is(aResponse.updated.length, 1, "updated prefs length");

    39   is(aResponse.updated[0], "NetworkMonitor.saveRequestAndResponseBodies",

    40      "updated prefs length");

    42   info("test network POST request");

    44   onNetworkEvent = onNetworkEvent.bind(null, aState);

    45   aState.dbgClient.addListener("networkEvent", onNetworkEvent);

    46   onNetworkEventUpdate = onNetworkEventUpdate.bind(null, aState);

    47   aState.dbgClient.addListener("networkEventUpdate", onNetworkEventUpdate);

    49   let iframe = document.querySelector("iframe").contentWindow;

    50   iframe.wrappedJSObject.testXhrPost();

    51 }

    53 function onNetworkEvent(aState, aType, aPacket)

    54 {

    55   is(aPacket.from, aState.actor, "network event actor");

    57   info("checking the network event packet");

    59   let netActor = aPacket.eventActor;

    61   checkObject(netActor, {

    62     actor: /[a-z]/,

    63     startedDateTime: /^\d+\-\d+\-\d+T.+$/,

    64     url: /data\.json/,

    65     method: "POST",

    66   });

    68   aState.netActor = netActor.actor;

    70   aState.dbgClient.removeListener("networkEvent", onNetworkEvent);

    71 }

    73 let updates = [];

    75 function onNetworkEventUpdate(aState, aType, aPacket)

    76 {

    77   info("received networkEventUpdate " + aPacket.updateType);

    78   is(aPacket.from, aState.netActor, "networkEventUpdate actor");

    80   updates.push(aPacket.updateType);

    82   let expectedPacket = null;

    84   switch (aPacket.updateType) {

    85     case "requestHeaders":

    86     case "responseHeaders":

    87       ok(aPacket.headers > 0, "headers > 0");

    88       ok(aPacket.headersSize > 0, "headersSize > 0");

    89       break;

    90     case "requestCookies":

    91       expectedPacket = {

    92         cookies: 3,

    93       };

    94       break;

    95     case "requestPostData":

    96       ok(aPacket.dataSize > 0, "dataSize > 0");

    97       ok(!aPacket.discardRequestBody, "discardRequestBody");

    98       break;

    99     case "responseStart":

   100       expectedPacket = {

   101         response: {

   102           httpVersion: /^HTTP\/\d\.\d$/,

   103           status: 200,

   104           statusText: "OK",

   105           headersSize: /^\d+$/,

   106           discardResponseBody: false,

   107         },

   108       };

   109       break;

   110     case "responseCookies":

   111       expectedPacket = {

   112         cookies: 0,

   113       };

   114       break;

   115     case "responseContent":

   116       expectedPacket = {

   117         mimeType: "application/json",

   118         contentSize: /^\d+$/,

   119         discardResponseBody: false,

   120       };

   121       break;

   122     case "eventTimings":

   123       expectedPacket = {

   124         totalTime: /^\d+$/,

   125       };

   126       break;

   127     default:

   128       ok(false, "unknown network event update type: " +

   129          aPacket.updateType);

   130       return;

   131   }

   133   if (expectedPacket) {

   134     info("checking the packet content");

   135     checkObject(aPacket, expectedPacket);

   136   }

   138   if (updates.indexOf("responseContent") > -1 &&

   139       updates.indexOf("eventTimings") > -1) {

   140     aState.dbgClient.removeListener("networkEventUpdate",

   141                                     onNetworkEvent);

   143     onRequestHeaders = onRequestHeaders.bind(null, aState);

   144     aState.client.getRequestHeaders(aState.netActor,

   145                                     onRequestHeaders);

   146   }

   147 }

   149 function onRequestHeaders(aState, aResponse)

   150 {

   151   info("checking request headers");

   153   ok(aResponse.headers.length > 0, "request headers > 0");

   154   ok(aResponse.headersSize > 0, "request headersSize > 0");

   156   checkHeadersOrCookies(aResponse.headers, {

   157     Referer: /network_requests_iframe\.html/,

   158     Cookie: /bug768096/,

   159   });

   161   onRequestCookies = onRequestCookies.bind(null, aState);

   162   aState.client.getRequestCookies(aState.netActor,

   163                                   onRequestCookies);

   164 }

   166 function onRequestCookies(aState, aResponse)

   167 {

   168   info("checking request cookies");

   170   is(aResponse.cookies.length, 3, "request cookies length");

   172   checkHeadersOrCookies(aResponse.cookies, {

   173     foobar: "fooval",

   174     omgfoo: "bug768096",

   175     badcookie: "bug826798=st3fan",

   176   });

   178   onRequestPostData = onRequestPostData.bind(null, aState);

   179   aState.client.getRequestPostData(aState.netActor,

   180                                    onRequestPostData);

   181 }

   183 function onRequestPostData(aState, aResponse)

   184 {

   185   info("checking request POST data");

   187   checkObject(aResponse, {

   188     postData: {

   189       text: /^Hello world! foobaz barr.+foobaz barr$/,

   190     },

   191     postDataDiscarded: false,

   192   });

   194   is(aResponse.postData.text.length, 552, "postData text length");

   196   onResponseHeaders = onResponseHeaders.bind(null, aState);

   197   aState.client.getResponseHeaders(aState.netActor,

   198                                    onResponseHeaders);

   199 }

   201 function onResponseHeaders(aState, aResponse)

   202 {

   203   info("checking response headers");

   205   ok(aResponse.headers.length > 0, "response headers > 0");

   206   ok(aResponse.headersSize > 0, "response headersSize > 0");

   208   checkHeadersOrCookies(aResponse.headers, {

   209     "Content-Type": /^application\/(json|octet-stream)$/,

   210     "Content-Length": /^\d+$/,

   211   });

   213   onResponseCookies = onResponseCookies.bind(null, aState);

   214   aState.client.getResponseCookies(aState.netActor,

   215                                   onResponseCookies);

   216 }

   218 function onResponseCookies(aState, aResponse)

   219 {

   220   info("checking response cookies");

   222   is(aResponse.cookies.length, 0, "response cookies length");

   224   onResponseContent = onResponseContent.bind(null, aState);

   225   aState.client.getResponseContent(aState.netActor,

   226                                    onResponseContent);

   227 }

   229 function onResponseContent(aState, aResponse)

   230 {

   231   info("checking response content");

   233   checkObject(aResponse, {

   234     content: {

   235       text: /"test JSON data"/,

   236     },

   237     contentDiscarded: false,

   238   });

   240   onEventTimings = onEventTimings.bind(null, aState);

   241   aState.client.getEventTimings(aState.netActor,

   242                                 onEventTimings);

   243 }

   245 function onEventTimings(aState, aResponse)

   246 {

   247   info("checking event timings");

   249   checkObject(aResponse, {

   250     timings: {

   251       blocked: /^-1|\d+$/,

   252       dns: /^-1|\d+$/,

   253       connect: /^-1|\d+$/,

   254       send: /^-1|\d+$/,

   255       wait: /^-1|\d+$/,

   256       receive: /^-1|\d+$/,

   257     },

   258     totalTime: /^\d+$/,

   259   });

   261   closeDebugger(aState, function() {

   262     SimpleTest.finish();

   263   });

   264 }

   266 addEventListener("load", startTest);

   267 </script>

   268 </body>

   269 </html>

The Tor Browser / file revision

toolkit/devtools/webconsole/test/test_network_post.html@129ffea94266

toolkit/devtools/webconsole/test/test_network_post.html