Cache Storage: replace assert_object_equals w/ assert_response_equals

LayoutTests/http/tests/cachestorage/script-tests/cache-match.js

 if (self.importScripts) {
     importScripts('/resources/testharness.js');
     importScripts('/resources/testharness-helpers.js');
     importScripts('../resources/test-helpers.js');
 }
 
 // A set of Request/Response pairs to be used with prepopulated_cache_test().
 var simple_entries = [
   {
     name: 'a',
@@ skipping 110 matching lines @@
     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, entries) {
     return cache.matchAll('not-present-in-the-cache')
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_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, entries) {
     return cache.match('not-present-in-the-cache')
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.match failures should resolve with undefined.');
         });
   }, 'Cache.match with no matching entries');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.matchAll(entries.a.request.url)
       .then(function(result) {
-          assert_array_equivalent(result, [entries.a.response],
+          assert_response_array_equivalent(result, [entries.a.response],
                                   'Cache.matchAll should match by URL.');
         });
   }, 'Cache.matchAll with URL');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.match(entries.a.request.url)
       .then(function(result) {
-          assert_object_equals_fixed(result, entries.a.response,
+          assert_response_equals(result, entries.a.response,
                                      'Cache.match should match by URL.');
         });
   }, 'Cache.match with URL');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.matchAll(entries.a.request)
       .then(function(result) {
-          assert_array_equivalent(result, [entries.a.response],
+          assert_response_array_equivalent(result, [entries.a.response],
                                   'Cache.matchAll should match by Request.');
         });
   }, 'Cache.matchAll with Request');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.match(entries.a.request)
       .then(function(result) {
-          assert_object_equals_fixed(result, entries.a.response,
+          assert_response_equals(result, entries.a.response,
                                      'Cache.match should match by Request.');
         });
   }, 'Cache.match with Request');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.matchAll(new Request(entries.a.request.url))
       .then(function(result) {
-          assert_array_equivalent(result, [entries.a.response],
+          assert_response_array_equivalent(result, [entries.a.response],
                                   'Cache.matchAll should match by Request.');
         });
   }, 'Cache.matchAll with new Request');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.match(new Request(entries.a.request.url))
       .then(function(result) {
-          assert_object_equals_fixed(result, entries.a.response,
+          assert_response_equals(result, entries.a.response,
                                      'Cache.match should match by Request.');
         });
   }, 'Cache.match with new Request');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.matchAll(entries.a.request,
                           {ignoreSearch: true})
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result,
             [
               entries.a.response,
               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, entries) {
     return cache.match(entries.a.request,
                        {ignoreSearch: true})
       .then(function(result) {
-          assert_object_in_array(
+          assert_response_in_array(
             result,
             [
               entries.a.response,
               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, entries) {
     return cache.matchAll(entries.a_with_query.request,
                           {ignoreSearch: true})
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result,
             [
               entries.a.response,
               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, entries) {
     return cache.match(entries.a_with_query.request,
                        {ignoreSearch: true})
       .then(function(result) {
-          assert_object_in_array(
+          assert_response_in_array(
             result,
             [
               entries.a.response,
               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, entries) {
     return cache.matchAll(entries.cat.request.url + '#mouse')
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result,
             [
               entries.cat.response,
             ],
             'Cache.matchAll should ignore URL fragment.');
         });
   }, 'Cache.matchAll with URL containing fragment');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.match(entries.cat.request.url + '#mouse')
       .then(function(result) {
-          assert_object_equals_fixed(result, entries.cat.response,
+          assert_response_equals(result, entries.cat.response,
                                      'Cache.match should ignore URL fragment.');
         });
   }, 'Cache.match with URL containing fragment');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.matchAll('http')
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_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, entries) {
     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, entries) {
     return cache.matchAll(entries.secret_cat.request.url)
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result, [entries.secret_cat.response],
             'Cache.matchAll should not ignore embedded credentials');
         });
   }, 'Cache.matchAll with URL containing credentials');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.match(entries.secret_cat.request.url)
       .then(function(result) {
-          assert_object_equals_fixed(
+          assert_response_equals(
             result, entries.secret_cat.response,
             'Cache.match should not ignore embedded credentials');
         });
   }, 'Cache.match with URL containing credentials');
 
 prepopulated_cache_test(vary_entries, function(cache, entries) {
     return cache.matchAll('http://example.com/c')
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result,
             [
               entries.vary_wildcard.response,
               entries.vary_cookie_absent.response
             ],
             'Cache.matchAll should exclude matches if a vary header is ' +
             'missing in the query request, but is present in the cached ' +
             'request.');
         })
 
       .then(function() {
           return cache.matchAll(
             new Request('http://example.com/c',
                         {headers: {'Cookies': 'none-of-the-above'}}));
         })
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result,
             [
               entries.vary_wildcard.response
             ],
             'Cache.matchAll should exclude matches if a vary header is ' +
             'missing in the cached request, but is present in the query ' +
             'request.');
         })
 
       .then(function() {
           return cache.matchAll(
             new Request('http://example.com/c',
                         {headers: {'Cookies': 'is-for-cookie'}}));
         })
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result,
             [entries.vary_cookie_is_cookie.response],
             'Cache.matchAll should match the entire header if a vary header ' +
             'is present in both the query and cached requests.');
         });
   }, 'Cache.matchAll with responses containing "Vary" header');
 
 prepopulated_cache_test(vary_entries, function(cache, entries) {
     return cache.match('http://example.com/c')
       .then(function(result) {
-          assert_object_in_array(
+          assert_response_in_array(
             result,
             [
               entries.vary_wildcard.response,
               entries.vary_cookie_absent.response
             ],
             'Cache.match should honor "Vary" header.');
         });
   }, 'Cache.match with responses containing "Vary" header');
 
 prepopulated_cache_test(vary_entries, function(cache, entries) {
     return cache.matchAll('http://example.com/c',
                           {ignoreVary: true})
       .then(function(result) {
-          assert_array_equivalent(
+          assert_response_array_equivalent(
             result,
             [
               entries.vary_cookie_is_cookie.response,
               entries.vary_cookie_is_good.response,
               entries.vary_cookie_absent.response,
               entries.vary_wildcard.response
             ],
             'Cache.matchAll should honor "ignoreVary" parameter.');
         });
   }, 'Cache.matchAll with "ignoreVary" parameter');
 
 cache_test(function(cache) {
     var request = new Request('http://example.com');
     var response;
     var request_url = new URL('../resources/simple.txt', location.href).href;
     return fetch(request_url)
       .then(function(fetch_result) {
           response = fetch_result;
           assert_equals(
             response.url, request_url,
             '[https://fetch.spec.whatwg.org/#dom-response-url] ' +
             'Reponse.url should return the URL of the response.');
           return cache.put(request, response.clone());
         })
       .then(function() {
           return cache.match(request.url);
         })
       .then(function(result) {
-          assert_object_equals_fixed(
+          assert_response_equals(
             result, response,
             'Cache.match should return a Response object that has the same ' +
             'properties as the stored response.');
           return cache.match(response.url);
         })
       .then(function(result) {
           assert_equals(
             result, undefined,
             'Cache.match should not match cache entry based on response URL.');
         });
@@ skipping 35 matching lines @@
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.match should not find a match');
       });
   }, 'Cache.match with POST Request');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     var response = entries.non_2xx_response.response;
     return cache.match(entries.non_2xx_response.request.url)
       .then(function(result) {
-          assert_object_equals_fixed(
+          assert_response_equals(
               result, entries.non_2xx_response.response,
               'Cache.match should return a Response object that has the ' +
                   'same properties as a stored non-2xx response.');
         });
   }, 'Cache.match with a non-2xx Response');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     var response = entries.error_response.response;
     return cache.match(entries.error_response.request.url)
       .then(function(result) {
-          assert_object_equals_fixed(
+          assert_response_equals(
               result, entries.error_response.response,
               'Cache.match should return a Response object that has the ' +
                   'same properties as a stored network error response.');
         });
   }, 'Cache.match with a network error Response');
 
 // Helpers ---
 
 // 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
@@ skipping 21 matching lines @@
           assert_equals(Object.keys(hash).length, entries.length);
         });
 
       return p.then(function() {
           return test_function(cache, hash);
         });
     }, description);
 }
 
 done();