[ServiceWorker] CacheStorage tests.

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

Index: LayoutTests/http/tests/serviceworker/resources/cache-storage-test-worker.js
diff --git a/LayoutTests/http/tests/serviceworker/resources/cache-storage-test-worker.js b/LayoutTests/http/tests/serviceworker/resources/cache-storage-test-worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..d0fc3ab48cb382d3bc40148bea7fae008c2484d6
--- /dev/null
+++ b/LayoutTests/http/tests/serviceworker/resources/cache-storage-test-worker.js
@@ -0,0 +1,78 @@
+importScripts('worker-test-harness.js');
+
+promise_test(function(test) {
+    return caches.create('foo')
+      .then(test.step_func(function(cache) {
+          assert_true(cache,

[dominicc (has gone to gerrit), 2014/08/11 01:57:36]

Maybe omit this assertion? You'll get a reasonable failure with the next
assertion.

[asanka, 2014/08/13 01:22:51]

Done.

+                      'CacheStorage.create should return a valid Cache.');
+          assert_true(cache instanceof Cache,
+                      'CacheStorage.create should return a valid Cache.');
+        }));
+  }, 'CacheStorage.create');
+
+promise_test(function(test) {
+    return caches.create()
+      // FIXME: Define the behavior for .create() with an empty or

[dominicc (has gone to gerrit), 2014/08/11 01:57:36]

I do not see any bias in the spec against '' as a cache name; I would expect
that to work?

Treating non-Strings will be specified by the Web IDL spec. The IDL declaration
in the Service Worker spec has the parameter as DOMString and not DOMString? so
that tells you null should be "null".

This is a good place to start:

http://www.w3.org/TR/WebIDL/#es-DOMString

[asanka, 2014/08/13 01:22:51]

Thanks for the reference! I've updated the tests.

+      // non-string cache name.
+      .then(test.unreached_func(
+              'CacheStorage.create should reject invalid name.'),
+            function() {});
+  }, 'CacheStorage.create with invalid cache name');
+
+promise_test(function(test) {
+    return caches.create('bar')
+      .then(test.step_func(function() { return caches.has('bar'); }))
+      .then(test.step_func(function(result) {
+          assert_true(result,
+                      'CacheStorage.has should return true for ' +
+                      'existing cache');
+        }));
+  }, 'CacheStorage.has with existing cache');
+
+promise_test(function(test) {
+    return caches.has('cheezburger')

[dominicc (has gone to gerrit), 2014/08/11 01:57:36]

Huge +1 to the modest sense of humor.

[asanka, 2014/08/13 01:22:51]

Acknowledged.

+      .then(test.step_func(function(result) {
+          assert_false(result,
+                       'CacheStorage.has should return false for ' +
+                       'non-existent cache');
+        }));
+  }, 'CacheStorage.has with non-existent cache');
+
+promise_test(function(test) {
+    return caches.has()
+      // FIXME: Define the behavior for .has() with an invalid or undefined
+      // name.  Perhaps it should reject instead of returning false.
+      .then(test.step_func(function(result) {
+          // FIXME: Could fail due to the cache creation with an undefined name
+          // above. Tests shouldn't interact since these are all async_tests.
+          assert_false(result,
+                       'CacheStorage.has should return false for invalid ' +
+                       'cache name.');
+        }));
+  }, 'CacheStorage.has with invalid cache name');
+
+promise_test(function(test) {
+    var cache_name = 'to-be-deleted';
+
+    return caches.create(cache_name)
+      .then(function() { return caches.delete(cache_name); })
+      .then(function() {},
+            test.unreached_func('CacheStorage.delete should not reject ' +
+                                'existing cache'))
+
+      .then(function() { return caches.has(cache_name); })
+      .then(test.step_func(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(test) {
+    return caches.delete('cheezburger')
+      .then(test.unreached_func('CacheStorage.delete should not fulfil ' +
+                                'promise to delete non-existent cache.'),
+            function() {});
+  }, 'CacheStorage.delete with non-existent cache');
+
+// FIXME: Define and test behavior for invalid cache name with delete().

[dominicc (has gone to gerrit), 2014/08/11 01:57:36]

You're free to file GitHub issues against the spec; make a proposal, refer to
the GitHub issue in a comment, and write the test along the lines you proposed.

Later we'll review the issues and update the test if the issue resolution went
another way.

[jsbell, 2014/08/11 22:48:34]

Yeah, I'm not clear what 'invalid' might mean here.

For Indexed DB we have tests for various edge cases to ensure that no extra
behavior was introduced:

* passing null (should stringify to "null", as dominicc@ mentions above)
* passing undefined (should stringify to "undefined")
* passing empty string ""
* passing strings with embedded NUL e.g. "abc\x00def"
* passing strings with non-ASCII characters e.g. "\xFF", "\uFFFD"
* passing strings with UTF-16 surrogate pairs e.g. "\uD800\uDC00" 
* passing strings with invalid UTF-16 sequences e.g. "\uDC00\uD800"

These funky strings should "just work", i.e. we're not validating the SW spec
itself since this is all covered by Web IDL as dominicc@ describes. Rather,
we're ensuring that we don't mis-handle those somewhere. These sorts of test
cases are worthwhile if the strings ever get used as something other than an
opaque in-memory string16 on the Chromium-side (e.g. used to create filenames,
serialized to files, etc)

Someone familiar with the Cache implementation (gavinp@?) might advise on
whether it's worth adding these sorts of tests for any aspect of the UI.

[asanka, 2014/08/13 01:22:51]

Thanks! I'll wait for gavinp to comment.