netwerk/test/unit/test_bug482934.js

   1 "use strict";
   2
   3 const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
   4
   5 var response_code;
   6 var response_body;
   7
   8 var request_time;
   9 var response_time;
  10
  11 var cache_storage;
  12
  13 var httpserver = new HttpServer();
  14 httpserver.start(-1);
  15
  16 var base_url = "http://localhost:" + httpserver.identity.primaryPort;
  17 var resource = "/resource";
  18 var resource_url = base_url + resource;
  19
  20 // Test flags
  21 var hit_server = false;
  22
  23 function make_channel(aUrl) {
  24   // Reset test global status
  25   hit_server = false;
  26
  27   var req = NetUtil.newChannel({ uri: aUrl, loadUsingSystemPrincipal: true });
  28   req.QueryInterface(Ci.nsIHttpChannel);
  29   req.setRequestHeader("If-Modified-Since", request_time, false);
  30   return req;
  31 }
  32
  33 function make_uri(aUrl) {
  34   return Services.io.newURI(aUrl);
  35 }
  36
  37 function resource_handler(aMetadata, aResponse) {
  38   hit_server = true;
  39   Assert.ok(aMetadata.hasHeader("If-Modified-Since"));
  40   Assert.equal(aMetadata.getHeader("If-Modified-Since"), request_time);
  41
  42   if (response_code == "200") {
  43     aResponse.setStatusLine(aMetadata.httpVersion, 200, "OK");
  44     aResponse.setHeader("Content-Type", "text/plain", false);
  45     aResponse.setHeader("Last-Modified", response_time, false);
  46
  47     aResponse.bodyOutputStream.write(response_body, response_body.length);
  48   } else if (response_code == "304") {
  49     aResponse.setStatusLine(aMetadata.httpVersion, 304, "Not Modified");
  50     aResponse.setHeader("Returned-From-Handler", "1");
  51   }
  52 }
  53
  54 function check_cached_data(aCachedData, aCallback) {
  55   asyncOpenCacheEntry(
  56     resource_url,
  57     "disk",
  58     Ci.nsICacheStorage.OPEN_READONLY,
  59     null,
  60     function(aStatus, aEntry) {
  61       Assert.equal(aStatus, Cr.NS_OK);
  62       pumpReadStream(aEntry.openInputStream(0), function(aData) {
  63         Assert.equal(aData, aCachedData);
  64         aCallback();
  65       });
  66     }
  67   );
  68 }
  69
  70 function run_test() {
  71   do_get_profile();
  72   evict_cache_entries();
  73
  74   do_test_pending();
  75
  76   cache_storage = getCacheStorage("disk");
  77   httpserver.registerPathHandler(resource, resource_handler);
  78
  79   wait_for_cache_index(run_next_test);
  80 }
  81
  82 // 1. send custom conditional request when we don't have an entry
  83 //    server returns 304 -> client receives 304
  84 add_test(() => {
  85   response_code = "304";
  86   response_body = "";
  87   request_time = "Thu, 1 Jan 2009 00:00:00 GMT";
  88   response_time = "Thu, 1 Jan 2009 00:00:00 GMT";
  89
  90   var ch = make_channel(resource_url);
  91   ch.asyncOpen(
  92     new ChannelListener(function(aRequest, aData) {
  93       syncWithCacheIOThread(() => {
  94         Assert.ok(hit_server);
  95         Assert.equal(
  96           aRequest.QueryInterface(Ci.nsIHttpChannel).responseStatus,
  97           304
  98         );
  99         Assert.ok(!cache_storage.exists(make_uri(resource_url), ""));
 100         Assert.equal(aRequest.getResponseHeader("Returned-From-Handler"), "1");
 101
 102         run_next_test();
 103       }, true);
 104     }, null)
 105   );
 106 });
 107
 108 // 2. send custom conditional request when we don't have an entry
 109 //    server returns 200 -> result is cached
 110 add_test(() => {
 111   response_code = "200";
 112   response_body = "content_body";
 113   request_time = "Thu, 1 Jan 2009 00:00:00 GMT";
 114   response_time = "Fri, 2 Jan 2009 00:00:00 GMT";
 115
 116   var ch = make_channel(resource_url);
 117   ch.asyncOpen(
 118     new ChannelListener(function(aRequest, aData) {
 119       syncWithCacheIOThread(() => {
 120         Assert.ok(hit_server);
 121         Assert.equal(
 122           aRequest.QueryInterface(Ci.nsIHttpChannel).responseStatus,
 123           200
 124         );
 125         Assert.ok(cache_storage.exists(make_uri(resource_url), ""));
 126
 127         check_cached_data(response_body, run_next_test);
 128       }, true);
 129     }, null)
 130   );
 131 });
 132
 133 // 3. send custom conditional request when we have an entry
 134 //    server returns 304 -> client receives 304 and cached entry is unchanged
 135 add_test(() => {
 136   response_code = "304";
 137   var cached_body = response_body;
 138   response_body = "";
 139   request_time = "Fri, 2 Jan 2009 00:00:00 GMT";
 140   response_time = "Fri, 2 Jan 2009 00:00:00 GMT";
 141
 142   var ch = make_channel(resource_url);
 143   ch.asyncOpen(
 144     new ChannelListener(function(aRequest, aData) {
 145       syncWithCacheIOThread(() => {
 146         Assert.ok(hit_server);
 147         Assert.equal(
 148           aRequest.QueryInterface(Ci.nsIHttpChannel).responseStatus,
 149           304
 150         );
 151         Assert.ok(cache_storage.exists(make_uri(resource_url), ""));
 152         Assert.equal(aRequest.getResponseHeader("Returned-From-Handler"), "1");
 153         Assert.equal(aData, "");
 154
 155         // Check the cache data is not changed
 156         check_cached_data(cached_body, run_next_test);
 157       }, true);
 158     }, null)
 159   );
 160 });
 161
 162 // 4. send custom conditional request when we have an entry
 163 //    server returns 200 -> result is cached
 164 add_test(() => {
 165   response_code = "200";
 166   response_body = "updated_content_body";
 167   request_time = "Fri, 2 Jan 2009 00:00:00 GMT";
 168   response_time = "Sat, 3 Jan 2009 00:00:00 GMT";
 169   var ch = make_channel(resource_url);
 170   ch.asyncOpen(
 171     new ChannelListener(function(aRequest, aData) {
 172       syncWithCacheIOThread(() => {
 173         Assert.ok(hit_server);
 174         Assert.equal(
 175           aRequest.QueryInterface(Ci.nsIHttpChannel).responseStatus,
 176           200
 177         );
 178         Assert.ok(cache_storage.exists(make_uri(resource_url), ""));
 179
 180         // Check the cache data is updated
 181         check_cached_data(response_body, () => {
 182           run_next_test();
 183           httpserver.stop(do_test_finished);
 184         });
 185       }, true);
 186     }, null)
 187   );
 188 });