[ServiceWorker] Tests for Cache

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

+importScripts('worker-testharness.js');
+importScripts('/resources/testharness-helpers.js');
+
+cache_test(function(cache) {
+    return assert_promise_rejects(

[asanka, 2014/10/22 22:35:32]

There are a few places where
https://github.com/slightlyoff/ServiceWorker/issues/523 is relevant. I.e. it's
not clear whether the cache.add() call is going to throw or whether the returned
promise is going to be rejected.

[jsbell, 2014/10/23 00:15:31]

The bindings layer should be doing the arity check and rejecting instead of
throwing, since the behavior here is defined in Web IDL (not the SW spec - it
happens before it hits the prose).

[jsbell, 2014/10/23 00:39:24]

Ah, the bindings code has a known issue: if the method is overloaded (like add()
is) and returns a promise (like add() is) we don't properly reject instead of
throw.

http://crbug.com/359386

I'll poke it now that the webidl issue has been resolved.

[asanka, 2014/10/23 06:12:39]

Acknowledged.

+      cache.add(),
+      new TypeError(),
+      'Cache.add should throw a TypeError when no arguments are given.');
+  }, 'Cache.add with no arguments');
+
+cache_test(function(cache) {
+    return cache.add('simple.txt')
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.add should resolve with undefined on success.');
+        });
+  }, 'Cache.add with successful request');
+
+cache_test(function(cache) {
+    return assert_promise_rejects(
+      cache.add('javascript://this-is-not-http-mmkay'),
+      'NetworkError',
+      'Cache.add with non-HTTP/HTTPS URL should throw a NetworkError.');
+  }, 'Cache.add with non-HTTP/HTTPS URL');
+
+cache_test(function(cache) {
+    var request = new Request('simple.txt', {body: 'Hello'});
+    return cache.add(request)
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.add should resolve with undefined on success.');
+        });
+  }, 'Cache.add with Request object');
+
+cache_test(function(cache) {
+    var request = new Request('simple.txt', {body: 'Hello'});
+    return request.text()
+      .then(function() {
+          assert_true(request.bodyUsed);
+        })
+      .then(function() {
+          return assert_promise_rejects(
+            cache.add(request),
+            new TypeError(),
+            'Cache.add with a Request object with a used body should reject ' +
+            'with a TypeError.');
+        });
+  }, 'Cache.add with a used Request object');
+
+cache_test(function(cache) {
+    var request = new Request('simple.txt', {body: 'Hello'});
+    return cache.add(request)
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.add should resolve with undefined on success.');
+        })
+      .then(function() {
+          return assert_promise_rejects(
+            cache.add(request),
+            new TypeError(),
+            'Cache.add should throw TypeError if same request is added twice.');
+        });
+  }, 'Cache.add called twice with same Request');
+
+cache_test(function(cache) {
+    return cache.add('this-does-not-exist-please-dont-create-it')
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.add should resolve with undefined on success.');
+        });
+  }, 'Cache.add with resource that results in a status of 404');
+
+cache_test(function(cache) {
+    return cache.add('fetch-status.php?status=500')
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.add should resolve with undefined on success.');
+        });
+  }, 'Cache.add with resource that results in a status of 500');
+
+cache_test(function(cache) {
+    return assert_promise_rejects(
+      cache.addAll(),
+      new TypeError(),
+      'Cache.addAll with no arguments should throw TypeError.');
+  }, 'Cache.addAll with no arguments');
+
+cache_test(function(cache) {
+    // Assumes the existence of simple.txt and blank.html in the same directory
+    // as this test script.
+    var urls = ['simple.txt', undefined, 'blank.html'];
+    return assert_promise_rejects(
+      cache.addAll(),
+      new TypeError(),
+      'Cache.addAll should throw TypeError for an undefined argument.');
+  }, 'Cache.addAll with undefined arguments');
+
+cache_test(function(cache) {
+    // Assumes the existence of simple.txt and blank.html in the same directory
+    // as this test script.
+    var urls = ['simple.txt', self.location.href, 'blank.html'];
+    return cache.addAll(urls)
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.addAll should resolve with undefined on success.');
+        });
+  }, 'Cache.addAll with ScalarValueString arguments');
+
+cache_test(function(cache) {
+    // Assumes the existence of simple.txt and blank.html in the same directory
+    // as this test script.
+    var urls = ['simple.txt', self.location.href, 'blank.html'];
+    var requests = urls.map(function(url) {
+        return new Request(url);
+      });
+    return cache.addAll(requests)
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.addAll should resolve with undefined on ' +
+                        'success.');
+        });
+  }, 'Cache.addAll with Request arguments');
+
+cache_test(function(cache) {
+    // Assumes that simple.txt and blank.html exist. The second
+    // resource does not.
+    var urls = ['simple.txt', 'this-resource-should-not-exist', 'blank.html'];
+    var requests = urls.map(function(url) {
+        return new Request(url);
+      });
+    return cache.addAll(requests)
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'Cache.addAll should resolve with undefined on ' +
+                        'success.');
+        });
+  }, 'Cache.addAll with failing request');
+
+cache_test(function(cache) {
+    var request = new Request('simple.txt');
+    return assert_promise_rejects(
+      cache.addAll([request, request]),
+      new TypeError(),
+      'Cache.addAll should throw TypeError if the same request is added ' +
+      'twice.');
+  }, 'Cache.addAll with the same Request twice');