[ServiceWorker] Update cache.match/matchAll tests.

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

 importScripts('worker-testharness.js');
 importScripts('/resources/testharness-helpers.js');
 
 // A set of Request/Response pairs to be used with prepopulated_cache_test().
 var simple_entries = {
   a: {
     request: new Request('http://example.com/a'),
     response: new Response('')
   },
 
@@ skipping 20 matching lines @@
   a_org: {
     request: new Request('http://example.org/a'),
     response: new Response('')
   },
 
   cat: {
     request: new Request('http://example.com/cat'),
     response: new Response('')
   },
 
-  cat_with_fragment: {
-    request: new Request('http://example.com/cat#mouse'),
+  catmandu: {
+    request: new Request('http://example.com/catmandu'),
+    response: new Response('')
+  },
+
+  cat_num_lives: {
+    request: new Request('http://example.com/cat?lives=9'),
     response: new Response('')
   },
 
   cat_in_the_hat: {
     request: new Request('http://example.com/cat/in/the/hat'),
     response: new Response('')
+  },
+
+  secret_cat: {
+    request: new Request('http://tom:jerry@example.com/cat'),
+    response: new Response('')
+  },
+
+  top_secret_cat: {
+    request: new Request('http://tom:j3rry@example.com/cat'),
+    response: new Response('')
   }
 };
 
 // A set of Request/Response pairs to be used with prepopulated_cache_test().
 // These contain a mix of test cases that use Vary headers.
 var vary_entries = {
   no_vary_header: {
     request: new Request('http://example.com/c'),
     response: new Response('')
   },
@@ skipping 20 matching lines @@
 
   vary_wildcard: {
     request: new Request('http://example.com/c',
                          {headers: {'Cookies': 'x', 'X-Key': '1'}}),
     response: new Response('',
                            {headers: {'Vary': '*'}})
   }
 };
 
 prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.matchAll('not-present-in-the-cache')
+      .then(function(result) {
+          assert_array_equivalent(
+            result, [],
+            'Cache.matchAll should resolve with an empty array on failure.');
+        });
+  }, 'Cache.matchAll with no matching entries');
+
+prepopulated_cache_test(simple_entries, function(cache) {
     return cache.match('not-present-in-the-cache')
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.match failures should resolve with undefined.');
         });
-  }, 'Cache.match failure');
+  }, 'Cache.match with no matching entries');
 
 prepopulated_cache_test(simple_entries, function(cache) {
     return cache.matchAll(simple_entries.a.request.url)
       .then(function(result) {
           assert_array_objects_equals(result, [simple_entries.a.response],
                                       'Cache.matchAll should match by URL.');
         });
   }, 'Cache.matchAll with URL');
 
 prepopulated_cache_test(simple_entries, function(cache) {
@@ skipping 75 matching lines @@
               simple_entries.a_with_query.response
             ],
             'Cache.matchAll with ignoreSearch should ignore the ' +
             'search parameters of cached request.');
         });
   },
   'Cache.matchAll with ignoreSearch option (request with no search ' +
   'parameters)');
 
 prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.match(simple_entries.a.request,
+                       {ignoreSearch: true})
+      .then(function(result) {
+          assert_object_in_array(
+            result,
+            [
+              simple_entries.a.response,
+              simple_entries.a_with_query.response
+            ],
+            'Cache.match with ignoreSearch should ignore the ' +
+            'search parameters of cached request.');
+        });
+  },
+  'Cache.match with ignoreSearch option (request with no search ' +
+  'parameters)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
     return cache.matchAll(simple_entries.a_with_query.request,
                           {ignoreSearch: true})
       .then(function(result) {
           assert_array_equivalent(
             result,
             [
               simple_entries.a.response,
               simple_entries.a_with_query.response
             ],
             'Cache.matchAll with ignoreSearch should ignore the ' +
             'search parameters of request.');
         });
   },
   'Cache.matchAll with ignoreSearch option (request with search parameter)');
 
 prepopulated_cache_test(simple_entries, function(cache) {
-    return cache.matchAll(simple_entries.cat.request)
+    return cache.match(simple_entries.a_with_query.request,
+                       {ignoreSearch: true})
+      .then(function(result) {
+          assert_object_in_array(
+            result,
+            [
+              simple_entries.a.response,
+              simple_entries.a_with_query.response
+            ],
+            'Cache.match with ignoreSearch should ignore the ' +
+            'search parameters of request.');
+        });
+  },
+  'Cache.match with ignoreSearch option (request with search parameter)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.matchAll(simple_entries.cat.request.url + '#mouse')
       .then(function(result) {
           assert_array_equivalent(
             result,
             [
               simple_entries.cat.response,
-              simple_entries.cat_with_fragment.response
             ],
-            'Cache.matchAll should ignore URL hash.');
+            'Cache.matchAll should ignore URL fragment.');
         });
-  }, 'Cache.matchAll with request containing hash');
+  }, 'Cache.matchAll with URL containing fragment');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.match(simple_entries.cat.request.url + '#mouse')
+      .then(function(result) {
+          assert_object_equals(result, simple_entries.cat.response,
+                               'Cache.match should ignore URL fragment.');
+        });
+  }, 'Cache.match with URL containing fragment');
 
 prepopulated_cache_test(simple_entries, function(cache) {
     return cache.matchAll('http')
       .then(function(result) {
           assert_array_equivalent(
             result, [],
             'Cache.matchAll should treat query as a URL and not ' +
             'just a string fragment.');
         });
   }, 'Cache.matchAll with string fragment "http" as query');
 
 prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.match('http')
+      .then(function(result) {
+          assert_equals(
+            result, undefined,
+            'Cache.match should treat query as a URL and not ' +
+            'just a string fragment.');
+        });
+  }, 'Cache.match with string fragment "http" as query');
+
+prepopulated_cache_test(simple_entries, function(cache) {
     return cache.matchAll('http://example.com/cat',
                           {prefixMatch: true})
       .then(function(result) {
           assert_array_equivalent(
             result,
             [
               simple_entries.cat.response,
-              simple_entries.cat_with_fragment.response,
+              simple_entries.catmandu.response,
+              simple_entries.cat_num_lives.response,
               simple_entries.cat_in_the_hat.response
             ],
             'Cache.matchAll should honor prefixMatch.');
         });
   }, 'Cache.matchAll with prefixMatch option');
 
 prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.match('http://example.com/cat',
+                       {prefixMatch: true})
+      .then(function(result) {
+          assert_object_in_array(
+            result,
+            [
+              simple_entries.cat.response,
+              simple_entries.catmandu.response,
+              simple_entries.cat_num_lives.response,
+              simple_entries.cat_in_the_hat.response
+            ],
+            'Cache.match should honor prefixMatch.');
+        });
+  }, 'Cache.match with prefixMatch option');
+
+prepopulated_cache_test(simple_entries, function(cache) {
     return cache.matchAll('http://example.com/cat/',
                           {prefixMatch: true})
       .then(function(result) {
           assert_array_equivalent(
             result, [simple_entries.cat_in_the_hat.response],
             'Cache.matchAll should honor prefixMatch.');
         });
-  }, 'Cache.matchAll with prefixMatch option');
+  }, 'Cache.matchAll with prefixMatch option (URL ending with path delimiter)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.match('http://example.com/cat/',
+                       {prefixMatch: true})
+      .then(function(result) {
+          assert_object_equals(
+            result, simple_entries.cat_in_the_hat.response,
+            'Cache.match should honor prefixMatch.');
+        });
+  }, 'Cache.match with prefixMatch option (URL ending with path delimiter)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.matchAll('http://tom:jerry@example.com', {prefixMatch: true})
+      .then(function(result) {
+          assert_array_equivalent(
+            result,
+            [
+              simple_entries.secret_cat.response,
+            ],
+            'Cache.matchAll should honor prefixMatch.');
+        });
+  }, 'Cache.matchAll with prefixMatch option (URL with embedded credentials)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.match('http://tom:jerry@example.com', {prefixMatch: true})
+      .then(function(result) {
+          assert_object_equals(
+            result, simple_entries.secret_cat.response,
+            'Cache.match should honor prefixMatch.');
+        });
+  }, 'Cache.match with prefixMatch option (URL with embedded credentials)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    // The string 'http://tom' should be converted to a URL and then serialized
+    // yielding 'http://tom/'. The trailing slash prevents the URL from matching
+    // the embedded credentials in the entries already in the cache.
+    return cache.matchAll('http://tom', {prefixMatch: true})
+      .then(function(result) {
+          assert_array_equivalent(
+            result, [],
+            'Cache.matchAll should honor prefixMatch.');
+        });
+  },
+  'Cache.matchAll with prefixMatch option (URL matching embedded credentials)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    // The string 'http://tom' should be converted to a URL and then serialized
+    // yielding 'http://tom/'. The trailing slash prevents the URL from matching
+    // the embedded credentials in the entries already in the cache.
+    return cache.match('http://tom', {prefixMatch: true})
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.match should honor prefixMatch.');
+        });
+  },
+  'Cache.match with prefixMatch option (URL matching embedded credentials)');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.matchAll(simple_entries.secret_cat.request.url)
+      .then(function(result) {
+          assert_array_equivalent(
+            result, [simple_entries.secret_cat.response],
+            'Cache.matchAll should not ignore embedded credentials');
+        });
+  }, 'Cache.matchAll with URL containing credentials');
+
+prepopulated_cache_test(simple_entries, function(cache) {
+    return cache.match(simple_entries.secret_cat.request.url)
+      .then(function(result) {
+          assert_object_equals(
+            result, simple_entries.secret_cat.response,
+            'Cache.match should not ignore embedded credentials');
+        });
+  }, 'Cache.match with URL containing credentials');
 
 prepopulated_cache_test(vary_entries, function(cache) {
     return cache.matchAll('http://example.com/c')
       .then(function(result) {
           assert_array_equivalent(
             result,
             [
               vary_entries.no_vary_header.response,
               vary_entries.vary_wildcard.response,
               vary_entries.vary_cookie_absent.response
@@ skipping 129 matching lines @@
 
 // Run |test_function| with a Cache object as its only parameter. Prior to the
 // call, the Cache is populated by cache entries from |entries|. The latter is
 // expected to be an Object mapping arbitrary keys to objects of the form
 // {request: <Request object>, response: <Response object>}.
 //
 // |test_function| should return a Promise that can be used with promise_test.
 function prepopulated_cache_test(entries, test_function, description) {
   cache_test(function(cache) {
       return Promise.all(Object.keys(entries).map(function(k) {
-          return cache.put(entries[k].request, entries[k].response);
+          return cache.put(entries[k].request, entries[k].response)
+            .catch(function(e) {
+                assert_unreached('Test setup failed for entry ' + k + ' : ' + e);
+              });
         }))
-        .catch(function(reason) {
-            assert_unreached('Test setup failed: ' + reason.message);
-          })
         .then(function() {
             return test_function(cache);
           });
     }, description);
 }