[ServiceWorker] CacheStorage tests.

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

+importScripts('worker-test-harness.js');
+
+promise_test(function(t) {
+    var cache_name = 'cache-storage/foo';
+    return self.caches.delete(cache_name)
+      .then(function() {
+          return self.caches.create(cache_name);
+        })
+      .then(function(cache) {
+          assert_true(cache instanceof Cache,
+                      'CacheStorage.create should return a Cache.');
+        });
+  }, 'CacheStorage.create');
+
+promise_test(function(t) {
+    // Note that this test may collide with other tests running in the same

[jsbell, 2014/08/20 17:54:13]

For Blink layout tests we won't run tests with the same storage directory in
parallel. It would only be an issue if this this didn't delete first, or if
*this* layout test was racy.

So... I think you're doing the right thing here and this is not an issue.

(if a user was running this in a browser loaded a bunch of tests into separate
tabs at the same time it could flake, but we can't do much about that)

[asanka, 2014/08/20 21:20:49]

Acknowledged.

+    // origin that also uses an empty cache name.
+    var cache_name = '';
+    return self.caches.delete(cache_name)
+      .then(function() {
+          return self.caches.create();
+        })
+      .then(function(cache) {
+          assert_true(cache instanceof Cache,
+                      'CacheStorage.create should accept an empty name.');
+        });
+  }, 'CacheStorage.create with an empty name');
+
+promise_test(function(t) {
+    var cache_name = 'cache-storage/there can be only one';

[jsbell, 2014/08/20 17:54:13]

No Highlander joke? I am disappoint!

[asanka, 2014/08/20 21:20:49]

:)

+    return self.caches(delete(cache_name))
+      .then(function() {
+          return self.caches.create(cache_name);
+        })
+      .then(function() {
+          return assert_promise_throws(
+            self.caches.create(cache_name),
+            'InvalidAccessError',
+            'CacheStorage.create should throw InvalidAccessError if called ' +
+            'with existing cache name.');
+        });
+  }, 'CacheStorage.create with an existing cache name');
+
+promise_test(function(t) {
+    var test_cases = [
+      { name: 'cache-storage/lowercase',

[jsbell, 2014/08/20 17:54:13]

nit: Per style guide, either wrap after { or no space.

[asanka, 2014/08/20 21:20:49]

Done.

+        should_not_match: [
+          'cache-storage/Lowercase',
+          ' cache-storage/lowercase',
+          'cache-storage/lowercase '
+        ] },
+      { name: 'cache-storage/has a space',
+        should_not_match: [
+          'cache-storage/has'
+        ] },
+      { name: 'cache-storage/has\000_in_the_name',
+        should_not_match: [
+          'cache-storage/has',
+          'cache-storage/has_in_the_name'
+        ] }
+    ];
+    return Promise.all(test_cases.map(function(testcase) {
+        var cache_name = testcase.name;
+        return self.caches.delete(cache_name)
+          .then(function() {
+              return self.caches.create(cache_name);
+            })
+          .then(function() {
+              return self.caches.has(cache_name);
+            })
+          .then(function(result) {
+              assert_true(result,
+                          'CacheStorage.has should return true for existing ' +
+                          'cache.');
+            })
+          .then(function() {
+              return Promise.all(
+                testcase.should_not_match.map(function(cache_name) {
+                    return self.caches.has(cache_name)
+                      .then(function(result) {
+                          assert_false(result,
+                                       'CacheStorage.has should only perform ' +
+                                       'exact matches on cache names.');
+                        });
+                  }));
+            })
+          .then(function() {
+              return self.caches.delete(cache_name);
+            });
+      }));
+  }, 'CacheStorage.has with existing cache');
+
+promise_test(function(t) {
+    return self.caches.has('cheezburger')
+      .then(function(result) {
+          assert_false(result,
+                       'CacheStorage.has should return false for ' +
+                       'nonexistent cache.');
+        });
+  }, 'CacheStorage.has with nonexistent cache');
+
+promise_test(function(t) {
+    var cache_name = 'cache-storage/get';
+    var cache;
+    return self.caches.create(cache_name)
+      .then(function(result) {
+          cache = result;
+          return self.caches.get(cache_name);
+        })
+      .then(function(result) {
+          assert_equals(result, cache,
+                        'CacheStorage.get should return the named Cache ' +
+                        'object if it exists.');
+          return self.caches.get(cache_name);
+        })
+      .then(function(result) {
+          assert_equals(result, cache,
+                        'CacheStorage.get should return the same ' +
+                        'instance of an existing Cache object.');
+        });
+  }, 'CacheStorage.get with existing cache');
+
+promise_test(function(t) {
+    return self.caches.get('cheezburger')
+      .then(function(result) {
+          assert_equals(result, undefined,
+                        'CacheStorage.get should return undefined for a ' +
+                        'nonexistent cache.');
+        });
+  }, 'CacheStorage.get with nonexistent cache');
+
+promise_test(function(t) {
+    var cache_name = 'cache-storage/delete';
+
+    return self.caches.create(cache_name)
+      .then(function() { return self.caches.delete(cache_name); })
+      .then(function(result) {
+          assert_true(result,
+                      'CacheStorage.delete should return true after ' +
+                      'deleting an existing cache.');
+        })
+
+      .then(function() { return self.caches.has(cache_name); })
+      .then(function(cache_exists) {
+          assert_false(cache_exists,
+                       'CacheStorage.has should not return true after ' +
+                       'fulfilment of CacheStorage.delete promise.');
+        });
+  }, 'CacheStorage.delete with existing cache');
+
+promise_test(function(t) {
+    return self.caches.delete('cheezburger')
+      .then(function(result) {
+          assert_false(result,
+                       'CacheStorage.delete should return false for a ' +
+                       'nonexistent cache.');
+        });
+  }, 'CacheStorage.delete with nonexistent cache');
+