Cache Storage API tests: Fix WPT test bugs, remove redundant local copies

third_party/WebKit/LayoutTests/http/tests/cachestorage/resources/test-helpers.js

Index: third_party/WebKit/LayoutTests/http/tests/cachestorage/resources/test-helpers.js
diff --git a/third_party/WebKit/LayoutTests/http/tests/cachestorage/resources/test-helpers.js b/third_party/WebKit/LayoutTests/http/tests/cachestorage/resources/test-helpers.js
deleted file mode 100644
index 61ddd123a350e4d8491153c05fbd6164a30bde5a..0000000000000000000000000000000000000000
--- a/third_party/WebKit/LayoutTests/http/tests/cachestorage/resources/test-helpers.js
+++ /dev/null
@@ -1,302 +0,0 @@
-(function() {
-  var next_cache_index = 1;
-
-  // Returns a promise that resolves to a newly created Cache object. The
-  // returned Cache will be destroyed when |test| completes.
-  function create_temporary_cache(test) {
-    var uniquifier = String(++next_cache_index);
-    var cache_name = self.location.pathname + '/' + uniquifier;
-
-    test.add_cleanup(function() {
-        self.caches.delete(cache_name);
-      });
-
-    return self.caches.delete(cache_name)
-      .then(function() {
-          return self.caches.open(cache_name);
-        });
-  }
-
-  self.create_temporary_cache = create_temporary_cache;
-})();
-
-// Runs |test_function| with a temporary unique Cache passed in as the only
-// argument. The function is run as a part of Promise chain owned by
-// promise_test(). As such, it is expected to behave in a manner identical (with
-// the exception of the argument) to a function passed into promise_test().
-//
-// E.g.:
-//    cache_test(function(cache) {
-//      // Do something with |cache|, which is a Cache object.
-//    }, "Some Cache test");
-function cache_test(test_function, description) {
-  promise_test(function(test) {
-      return create_temporary_cache(test)
-        .then(cache => test_function(cache, test));
-    }, description);
-}
-
-// A set of Request/Response pairs to be used with prepopulated_cache_test().
-var simple_entries = [
-  {
-    name: 'a',
-    request: new Request('http://example.com/a'),
-    response: new Response('')
-  },
-
-  {
-    name: 'b',
-    request: new Request('http://example.com/b'),
-    response: new Response('')
-  },
-
-  {
-    name: 'a_with_query',
-    request: new Request('http://example.com/a?q=r'),
-    response: new Response('')
-  },
-
-  {
-    name: 'A',
-    request: new Request('http://example.com/A'),
-    response: new Response('')
-  },
-
-  {
-    name: 'a_https',
-    request: new Request('https://example.com/a'),
-    response: new Response('')
-  },
-
-  {
-    name: 'a_org',
-    request: new Request('http://example.org/a'),
-    response: new Response('')
-  },
-
-  {
-    name: 'cat',
-    request: new Request('http://example.com/cat'),
-    response: new Response('')
-  },
-
-  {
-    name: 'catmandu',
-    request: new Request('http://example.com/catmandu'),
-    response: new Response('')
-  },
-
-  {
-    name: 'cat_num_lives',
-    request: new Request('http://example.com/cat?lives=9'),
-    response: new Response('')
-  },
-
-  {
-    name: 'cat_in_the_hat',
-    request: new Request('http://example.com/cat/in/the/hat'),
-    response: new Response('')
-  },
-
-  {
-    name: 'non_2xx_response',
-    request: new Request('http://example.com/non2xx'),
-    response: new Response('', {status: 404, statusText: 'nope'})
-  },
-
-  {
-    name: 'error_response',
-    request: new Request('http://example.com/error'),
-    response: Response.error()
-  },
-];
-
-// 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 = [
-  {
-    name: 'vary_cookie_is_cookie',
-    request: new Request('http://example.com/c',
-                         {headers: {'Cookies': 'is-for-cookie'}}),
-    response: new Response('',
-                           {headers: {'Vary': 'Cookies'}})
-  },
-
-  {
-    name: 'vary_cookie_is_good',
-    request: new Request('http://example.com/c',
-                         {headers: {'Cookies': 'is-good-enough-for-me'}}),
-    response: new Response('',
-                           {headers: {'Vary': 'Cookies'}})
-  },
-
-  {
-    name: 'vary_cookie_absent',
-    request: new Request('http://example.com/c'),
-    response: new Response('',
-                           {headers: {'Vary': 'Cookies'}})
-  }
-];
-
-// Run |test_function| with a Cache object and a map of entries. 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>}. The entries are
-// added sequentially so that tests can verify the ordering of the cache
-// methods.
-//
-// |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) {
-      var hash = {};
-      var resolveMethod = null;
-
-      var promise = new Promise(function(resolve, reject) {
-          resolveMethod = resolve;
-        })
-      .then(function() {
-          assert_equals(Object.keys(hash).length, entries.length);
-          return test_function(cache, hash);
-        });
-
-      // Add the entries to the cache sequentially.
-      // TODO(jkarlin): Once async/await is available use it to prettify this
-      // code.
-      var i = 0;
-      var processNextEntry = function(i) {
-          if (i == entries.length) {
-            resolveMethod();
-            return;
-          }
-          entry = entries[i];
-          hash[entry.name] = entry;
-          cache.put(entry.request.clone(), entry.response.clone())
-          .then(function() {
-              processNextEntry(i+1);
-            })
-          .catch(function(e) {
-              assert_unreached(
-                'Test setup failed for entry ' + entry.name + ': ' + e);
-            })
-        }
-
-      processNextEntry(0);
-      return promise;
-    }, description);
-}
-
-// Helper for testing with Headers objects. Compares Headers instances
-// by serializing |expected| and |actual| to arrays and comparing.
-function assert_header_equals(actual, expected, description) {
-    assert_class_string(actual, "Headers", description);
-    var header;
-    var actual_headers = [];
-    var expected_headers = [];
-    for (header of actual)
-        actual_headers.push(header[0] + ": " + header[1]);
-    for (header of expected)
-        expected_headers.push(header[0] + ": " + header[1]);
-    assert_array_equals(actual_headers, expected_headers,
-                        description + " Headers differ.");
-}
-
-// Helper for testing with Response objects. Compares simple
-// attributes defined on the interfaces, as well as the headers. It
-// does not compare the response bodies.
-function assert_response_equals(actual, expected, description) {
-    assert_class_string(actual, "Response", description);
-    ["type", "url", "status", "ok", "statusText"].forEach(function(attribute) {
-        assert_equals(actual[attribute], expected[attribute],
-                      description + " Attributes differ: " + attribute + ".");
-    });
-    assert_header_equals(actual.headers, expected.headers, description);
-}
-
-// Asserts that two arrays |actual| and |expected| contain the same
-// set of Responses as determined by assert_response_equals(). The
-// corresponding elements must occupy corresponding indices in their
-// respective arrays.
-function assert_response_array_equals(actual, expected, description) {
-    assert_true(Array.isArray(actual), description);
-    assert_equals(actual.length, expected.length, description);
-    actual.forEach(function(value, index) {
-        assert_response_equals(value, expected[index],
-                               description + " : object[" + index + "]");
-    });
-}
-
-// Equivalent to assert_in_array, but uses assert_response_equals.
-function assert_response_in_array(actual, expected_array, description) {
-    assert_true(expected_array.some(function(element) {
-        try {
-            assert_response_equals(actual, element);
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }), description);
-}
-
-// Helper for testing with Request objects. Compares simple
-// attributes defined on the interfaces, as well as the headers.
-function assert_request_equals(actual, expected, description) {
-    assert_class_string(actual, "Request", description);
-    ["url"].forEach(function(attribute) {
-        assert_equals(actual[attribute], expected[attribute],
-                      description + " Attributes differ: " + attribute + ".");
-    });
-    assert_header_equals(actual.headers, expected.headers, description);
-}
-
-// TODO(zino): Should remove this function once keys() returns request
-// keys in key insertion order. Please see http://crbug.com/627821.
-//
-// Assert that the two arrays |actual| and |expected| contain the same
-// set of Requests as determined by assert_request_equals. The order
-// is not significant.
-//
-// |expected| is assumed to not contain any duplicates.
-function assert_request_array_equivalent(actual, expected, description) {
-    assert_true(Array.isArray(actual), description);
-    assert_equals(actual.length, expected.length, description);
-    expected.forEach(function(expected_element) {
-        // assert_request_in_array treats the first argument as being
-        // 'actual', and the second as being 'expected array'. We are
-        // switching them around because we want to be resilient
-        // against the |actual| array containing duplicates.
-        assert_request_in_array(expected_element, actual, description);
-    });
-}
-
-// Asserts that two arrays |actual| and |expected| contain the same
-// set of Requests as determined by assert_request_equals(). The
-// corresponding elements must occupy corresponding indices in their
-// respective arrays.
-function assert_request_array_equals(actual, expected, description) {
-    assert_true(Array.isArray(actual), description);
-    assert_equals(actual.length, expected.length, description);
-    actual.forEach(function(value, index) {
-        assert_request_equals(value, expected[index],
-                              description + " : object[" + index + "]");
-    });
-}
-
-// Equivalent to assert_in_array, but uses assert_request_equals.
-function assert_request_in_array(actual, expected_array, description) {
-    assert_true(expected_array.some(function(element) {
-        try {
-            assert_request_equals(actual, element);
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }), description);
-}
-
-// Deletes all caches, returning a promise indicating success.
-function delete_all_caches() {
-  return self.caches.keys()
-    .then(function(keys) {
-      return Promise.all(keys.map(self.caches.delete.bind(self.caches)));
-    });
-}