[ServiceWorker] Add Cache.put tests for URL fragment handling.

LayoutTests/http/tests/serviceworker/resources/cache-put-worker.js

 importScripts('worker-testharness.js');
 importScripts('/resources/testharness-helpers.js');
 
 var test_url = 'https://example.com/foo';
 
 // Construct a generic Request object. The URL is |test_url|. All other fields

[jsbell, 2014/11/06 22:48:37]

Nit: adjust comment

But... what's the advantage for the callers over calling new Request(url) ?

[asanka, 2014/11/06 23:42:00]

None whatsoever. Removed!

 // are defaults.
-function new_test_request() {
-  return new Request(test_url);
+function new_test_request(url) {
+  url = url || test_url;
+  return new Request(url);
 }
 
 // Construct a generic Response object. The URL is empty. If specified |body|
 // will be set as the response body string.
 function new_test_response(body) {
   body = body || 'Hello world!';
   return new Response(body, {
       status: 200,
       statusText: 'OK',
       headers: [['Content-Type', 'text/plain']]
@@ skipping 92 matching lines @@
                         'Cache.put should store response body.');
         });
   }, 'Cache.put with an empty response body');
 
 cache_test(function(cache) {
     var test_url = new URL('fetch-status.php?status=500', location.href).href;
     var request = new Request(test_url);
     var response;
     return fetch(test_url)
       .then(function(fetch_result) {
+          assert_equals(fetch_result.status, 500,
+                        'Test framework error: The status code should be 500.');
           response = fetch_result.clone();
           return cache.put(request, fetch_result);
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
           assert_object_equals(result, response,
                                'Cache.put should update the cache with ' +
                                'new request and response.');
           return result.text();
         })
       .then(function(body) {
           assert_equals(body, '',
                         'Cache.put should store response body.');
         });
   }, 'Cache.put with HTTP 500 response');
 
 cache_test(function(cache) {
-    var alternate_response = new_test_response('Lorem ipsum');
-    return cache.put(new_test_request(), new_test_response())
+    var alternate_response_body = 'New body';
+    var alternate_response = new_test_response(alternate_response_body);
+    return cache.put(new_test_request(),
+                     new_test_response('Old body'))
       .then(function() {
           return cache.put(new_test_request(), alternate_response);
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
           assert_object_equals(result, alternate_response,
                                'Cache.put should replace existing ' +
                                'response with new response.');
+          return result.text();
+        })
+      .then(function(body) {
+          assert_equals(body, alternate_response_body,
+                        'Cache put should store new response body.');
         });
-  }, 'Cache.put called twice with same Request and different Responses');
+  }, 'Cache.put called twice with matching Requests and different Responses');
+
+cache_test(function(cache) {
+    var first_url = test_url;
+    var second_url = first_url + '#(O_o)';
+    var alternate_response_body = 'New body';
+    var alternate_response = new_test_response(alternate_response_body);
+    return cache.put(new_test_request(first_url),
+                     new_test_response('Old body'))
+      .then(function() {
+          return cache.put(new_test_request(second_url), alternate_response);
+        })
+      .then(function() {
+          return cache.match(test_url);
+        })
+      .then(function(result) {
+          assert_object_equals(result, alternate_response,

[jsbell, 2014/11/06 22:48:37]

It's a bit weird since this assertion currently passes (since the old and new
responses only differ in body), but I guess it defends against future failures.

[asanka, 2014/11/06 23:42:00]

Yeah. I removed the new_test_response() function as well, and I'm now explicitly
creating Response objects that differ in body as well as statusText. The test is
now failing as expected and this step correctly catches the failure to replace
the response.

+                               'Cache.put should replace existing ' +
+                               'response with new response.');
+          return result.text();
+        })
+      .then(function(body) {
+          assert_equals(body, alternate_response_body,
+                        'Cache put should store new response body.');
+        });
+  }, 'Cache.put called twice with request URLs that differ only by a fragment');
+
+cache_test(function(cache) {
+    var entries = {
+      dark: {
+        url: 'http://darkhelmet:12345@example.com/spaceballs',
+        body: 'Moranis'
+      },
+
+      skroob: {
+        url: 'http://skroob:12345@example.com/spaceballs',
+        body: 'Brooks'
+      },
+
+      control: {
+        url: 'http://example.com/spaceballs',
+        body: 'v(o.o)v'
+      }
+    };
+
+    return Promise.all(Object.keys(entries).map(function(key) {
+        return cache.put(new_test_request(entries[key].url),
+                         new_test_response(entries[key].body));
+      }))
+      .then(function() {
+          return Promise.all(Object.keys(entries).map(function(key) {
+              return cache.match(entries[key].url)
+                .then(function(result) {
+                    return result.text();
+                  })
+                .then(function(body) {
+                    assert_equals(body, entries[key].body,
+                                  'Cache put should store response body.');
+                  });
+            }));
+        });
+  }, 'Cache.put with request URLs containing embedded credentials');
 
 cache_test(function(cache) {
     var url = 'http://example.com/foo';
     return cache.put(url, new_test_response('some body'))
       .then(function() { return cache.match(url); })
       .then(function(response) { return response.text(); })
       .then(function(body) {
           assert_equals(body, 'some body',
                         'Cache.put should accept a string as request.');
         });
-  }, 'Cache.put with an string request');
+  }, 'Cache.put with a string request');
 
 cache_test(function(cache) {
     return assert_promise_rejects(
       cache.put(new_test_request(), 'Hello world!'),
       new TypeError(),
       'Cache.put should only accept a Response object as the response.');
   }, 'Cache.put with an invalid response');
 
 cache_test(function(cache) {
     return assert_promise_rejects(
@@ skipping 22 matching lines @@
       new TypeError(),
       'Cache.put should throw a TypeError for non-GET requests.');
   }, 'Cache.put with a non-GET request');
 
 cache_test(function(cache) {
     return assert_promise_rejects(
       cache.put(new_test_request(), null),
       new TypeError(),
       'Cache.put should throw a TypeError for an empty response.');
   }, 'Cache.put with an empty response');