Finished storage polyfill.

tests/js/polyfills/storage.polyfill.test.js

 // Copyright 2015 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 136 matching lines @@
 
 QUnit.module('storage', {
     beforeEach: function () {
       localforage.setItem('test1', 123);
       localforage.setItem('test2', '456');
       sandbox.stub(chrome.caterpillar, 'setError');
     },
     afterEach: function() {
       sandbox.restore();
       localforage.willError = false;
+      localforage.clear();
+      chrome.caterpillar.storage.resetOnChangedListenersForTests();
     }
 });
 
 // All storage areas are assumed to be the same in this polyfill.
 QUnit.test('all storage areas are the same', assert => {
   assert.ok(chrome.storage.sync === chrome.storage.local &&
             chrome.storage.local === chrome.storage.managed)
 });
 
 QUnit.test('get sends errors to caterpillar when retrieving all items',
@@ skipping 76 matching lines @@
 });
 
 QUnit.test('get can get key value pairs with defaults', function(assert) {
   var done = assert.async();
   chrome.storage.local.get({'notakey': 'default'}, function(items) {
     assert.strictEqual(items['notakey'], 'default');
     done();
   });
 });
 
-// TODO(alger): Test onChanged using set and remove.
+QUnit.test('getBytesInUse sets an error', function(assert) {
+  var done = assert.async();
+  chrome.storage.local.getBytesInUse([], function() {
+    assert.equal(chrome.caterpillar.setError.args[0][0],
+                 'getBytesInUse not implemented.');
+    done();
+  });
+});
+
+QUnit.test('getBytesInUse juggles arguments', function(assert) {
+  var done = assert.async();
+  chrome.storage.local.getBytesInUse(done);
+  assert.expect(0);
+});
+
+QUnit.test('can set key/value pairs', function(assert) {
+  var done = assert.async();
+  chrome.storage.local.set({'hello': 'world', 'test': 123}, function() {
+    localforage.getItem('hello')
+        .then(function(value) {
+          assert.strictEqual(value, 'world');
+          return localforage.getItem('test');
+        })
+        .then(function(value) {
+          assert.strictEqual(value, 123);
+          done();
+        });
+  });
+});
+
+QUnit.test('can remove a single item', function(assert) {
+  var done = assert.async();
+  chrome.storage.local.remove('test1', function() {
+    localforage.getItem('test1').then(function(value) {
+      assert.strictEqual(value, null);
+      done();
+    });
+  });
+});
+
+QUnit.test('can remove multiple items', function(assert) {
+  var done = assert.async();
+  chrome.storage.local.remove(['test1', 'test2'], function() {
+    localforage.getItem('test1')
+        .then(function(value) {
+          assert.strictEqual(value, null);
+          return localforage.getItem('test2');
+        })
+        .then(function(value) {
+          assert.strictEqual(value, null);
+          done();
+        });
+  });
+});
+
+QUnit.test('can clear all items', function(assert) {
+  var done = assert.async();
+  chrome.storage.local.clear(function() {
+    localforage.getItem('test1')
+        .then(function(value) {
+          assert.strictEqual(value, null);
+          return localforage.getItem('test2');
+        })
+        .then(function(value) {
+          assert.strictEqual(value, null);
+          done();
+        });
+  });
+});
+
+QUnit.test('set runs onChanged handlers', function(assert) {
+  var done = assert.async();
+  chrome.storage.onChanged.addListener(function(changes) {
+    assert.strictEqual(changes['test1'].oldValue, 123);
+    assert.strictEqual(changes['test1'].newValue, 'hello');
+    done();
+  });
+  chrome.storage.local.set({'test1': 'hello'});
+});
+
+QUnit.test('set runs multiple onChanged handlers', function(assert) {
+  assert.expect(0);

[raymes, 2016/01/18 00:25:20]

What's this for?

[Matthew Alger, 2016/01/18 00:37:37]

expect tells QUnit how many assertions there will be in the test. This tells
QUnit we don't expect any assertions - we just expect the handlers to be called.

[raymes, 2016/01/18 02:13:34]

I see - so do things fail without this? If not then I think you could just
remove it. I could see using this if you wanted to check that some assertion was
called n times.

[Matthew Alger, 2016/01/18 02:14:58]

Yes, QUnit will explicitly fail if there are no assertions. expect(0) is
something of a special case.

+  var done = assert.async(2);
+  chrome.storage.onChanged.addListener(function(changes) {
+    done();
+  });
+  chrome.storage.onChanged.addListener(function(changes) {
+    done();
+  });
+  chrome.storage.local.set({'test1': 'hello'});
+});
+
+QUnit.test('removing 1 key runs onChanged handlers', function(assert) {
+  var done = assert.async();
+  chrome.storage.onChanged.addListener(function(changes) {
+    assert.strictEqual(changes['test1'].oldValue, 123);
+    assert.strictEqual(changes['test1'].newValue, null);
+    done();
+  });
+  chrome.storage.local.remove('test1');
+});
+
+QUnit.test('removing 1 key runs multiple onChanged handlers', function(assert) {
+  assert.expect(0);
+  var done = assert.async(2);
+  chrome.storage.onChanged.addListener(function(changes) {
+    done();
+  });
+  chrome.storage.onChanged.addListener(function(changes) {
+    done();
+  });
+  chrome.storage.local.remove('test1');
+});
+
+QUnit.test('removing multiple keys runs onChanged handlers', function(assert) {
+  var done = assert.async();
+  chrome.storage.onChanged.addListener(function(changes) {
+    assert.strictEqual(changes['test1'].oldValue, 123);
+    assert.strictEqual(changes['test1'].newValue, null);
+    assert.strictEqual(changes['test2'].oldValue, '456');
+    assert.strictEqual(changes['test2'].newValue, null);
+    done();
+  });
+  chrome.storage.local.remove(['test1', 'test2']);
+});
+
+QUnit.test('removing multiple keys runs multiple onChanged handlers',
+    function(assert) {
+      assert.expect(0);
+      var done = assert.async(2);
+      chrome.storage.onChanged.addListener(function(changes) {
+        done();
+      });
+      chrome.storage.onChanged.addListener(function(changes) {
+        done();
+      });
+      chrome.storage.local.remove('test1');
+    }
+);
+
+QUnit.test('clearing runs onChanged handlers', function(assert) {
+  var done = assert.async();
+  chrome.storage.onChanged.addListener(function(changes) {
+    assert.strictEqual(changes['test1'].oldValue, 123);
+    assert.strictEqual(changes['test1'].newValue, null);
+    assert.strictEqual(changes['test2'].oldValue, '456');
+    assert.strictEqual(changes['test2'].newValue, null);
+    done();
+  });
+  chrome.storage.local.clear();
+});
+
+QUnit.test('clearing runs multiple onChanged handlers', function(assert) {
+  assert.expect(0);
+  var done = assert.async(2);
+  chrome.storage.onChanged.addListener(function(changes) {
+    done();
+  });
+  chrome.storage.onChanged.addListener(function(changes) {

[raymes, 2016/01/18 00:25:20]

You could probably merge all the multiple handler tests into the single handler
ones - testing multiple would presumably cover the single case

[Matthew Alger, 2016/01/18 00:37:37]

I'm not sure that's entirely true. It's easily possible to implement this such
that only one handler can be registered at a time, and having single/multiple
split like this would reveal that.

[raymes, 2016/01/18 02:13:34]

I agree. But having only the multiple test would also catch that. The only thing
it wouldn't catch is if things worked with multiple handlers but not with a
single handler and it would be hard to write things in a way where that was the
case. But since they're already written, I'm ok leaving them. 

[Matthew Alger, 2016/01/18 02:14:58]

Acknowledged.

+    done();
+  });
+  chrome.storage.local.clear();
+});