Notifications work in service workers. Resolves #14.

tests/js/polyfills/notifications.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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 var sandbox = sinon.sandbox.create();
 
 QUnit.module('notifications', {
     beforeEach: function () {
       this.close = sinon.spy();
+      var close = this.close;

[raymes, 2016/01/28 04:36:56]

Can this be inlined?

[Matthew Alger, 2016/01/28 05:18:02]

Yup. Done.

       var Notification = sandbox.stub(self, 'Notification')
-          .returns({close: this.close});
+          .returns({close: close});
       var requestPermission = sandbox.stub(Notification, 'requestPermission')
           .callsArg(0)  // Deprecated callback.
           .returns(Promise.resolve());
+      this.getRegistration = chrome.caterpillar.notifications.getRegistration;

[raymes, 2016/01/28 04:36:56]

This seems unneeded

[Matthew Alger, 2016/01/28 05:18:02]

It was so that I could restore getRegistration later, but I guess that's
pointless. Removed.

+      this.showNotification = sandbox.spy(function(title, opts) {
+        this.notifications.push({title: title, opts: opts, close: close});
+        return Promise.resolve();
+      });

[raymes, 2016/01/28 04:36:56]

This would be clearer if you defined:
this.registration = {
};

Then you could return the registration directly in getRegistration below. You
could also check this.registration.showNotificaiton.calledOnce.

[Matthew Alger, 2016/01/28 05:18:02]

Done.

+      chrome.caterpillar.notifications.getRegistration = sinon.stub()
+          .returns(Promise.resolve({
+            notifications: [],
+            showNotification: this.showNotification,
+            getNotifications: function() {
+              return Promise.resolve(this.notifications)
+            },
+          }));
     },
     afterEach: function() {
       sandbox.restore();
     }
 });
 
 QUnit.test('creates a minimal notification', function(assert) {
   var done = assert.async();
-  var opts = {'type': 'basic'}
+  var opts = {'type': 'basic'};
+  var showNotification = this.showNotification;
   chrome.notifications.create(opts, function() {
-    assert.ok(Notification.calledOnce);
+    assert.ok(Notification.calledOnce || showNotification.calledOnce);
     done();
   });
 });
 
 QUnit.test('creates a notification with correct body', function(assert) {
   var done = assert.async();
-  var opts = {'type': 'basic', 'message': 'méssage'}
+  var opts = {'type': 'basic', 'message': 'méssage'};
+  var showNotification = this.showNotification;
   chrome.notifications.create(opts, function() {
-    assert.equal(Notification.args[0][1].body, 'méssage');
+    var creator = Notification.called ? Notification : showNotification;

[raymes, 2016/01/28 04:36:56]

This would be simpler if we just had the one codepath for creating
notifications, which I would recommend.

[Matthew Alger, 2016/01/28 05:18:02]

Do you mean dropping support for new Notification? I am not sure whether that's
a good idea.

+    assert.equal(creator.args[0][1].body, 'méssage');
     done();
   });
 });
 
 QUnit.test('creates a notification with correct title',
     function(assert) {
       var done = assert.async();
-      var opts = {'type': 'basic', 'title': 'títle'}
+      var opts = {'type': 'basic', 'title': 'títle'};
+      var showNotification = this.showNotification;
       chrome.notifications.create(opts, function() {
-        assert.equal(Notification.args[0][0], 'títle');
+        var creator = Notification.called ? Notification : showNotification;
+        assert.equal(creator.args[0][0], 'títle');
         done();
       });
     }
 );
 
 QUnit.test('creates a notification with correct ID', function(assert) {
   var done = assert.async();
-  var opts = {'type': 'basic', 'title': 'títle'}
+  var opts = {'type': 'basic', 'title': 'títle'};
+  var showNotification = this.showNotification;
   chrome.notifications.create('íd', opts, function() {
-    assert.equal(Notification.args[0][1].tag, 'íd');
+    var creator = Notification.called ? Notification : showNotification;
+    assert.equal(creator.args[0][1].tag, 'íd');
     done();
   });
 });
 
 QUnit.test('create closes notifications with same ID', function(assert) {
   var done = assert.async();
   var close = this.close;
   chrome.notifications.create('íde', {'type': 'basic'}, function() {
     chrome.notifications.create('íde', {'type': 'basic'}, function() {
       assert.ok(close.calledOnce);
       done();
     });
   });
 });
 
 QUnit.test('create generates an ID if none is provided', function(assert) {
   var done = assert.async();
   var clear = sandbox.stub(chrome.notifications, 'clear');
+  var showNotification = this.showNotification;
   chrome.notifications.create({'type': 'basic'}, function() {
-    assert.ok('tag' in Notification.args[0][1]);
-    assert.equal(typeof Notification.args[0][1].tag, 'string');
+    var creator = Notification.called ? Notification : showNotification;
+    assert.ok('tag' in creator.args[0][1]);
+    assert.equal(typeof creator.args[0][1].tag, 'string');
     done();
   });
 });
 
 QUnit.test('create requests notification permissions', function(assert) {
   var done = assert.async();
   chrome.notifications.create({'type': 'basic'}, function() {
     assert.ok(Notification.requestPermission.calledOnce);
     done();
   });
 });
 
 QUnit.test('create appends the contextMessage to the body', function(assert) {
   var done = assert.async();
+  var showNotification = this.showNotification;
   chrome.notifications.create({'type': 'basic', 'message': 'hello',
                                'contextMessage': 'world'}, function() {
-    assert.equal(Notification.args[0][1].body, 'hello\n\nworld');
+    var creator = Notification.called ? Notification : showNotification;
+    assert.equal(creator.args[0][1].body, 'hello\n\nworld');
     done();
   });
 });
 
 QUnit.test('create adds progress text for progress notifications',
   function(assert) {
     var done = assert.async();
+    var showNotification = this.showNotification;
     chrome.notifications.create({'type': 'progress', 'message': 'hello',
                                  'progress': 15}, function() {
-      assert.equal(Notification.args[0][1].body, 'hello\n\nProgress: 15%');
+      var creator = Notification.called ? Notification : showNotification;
+      assert.equal(creator.args[0][1].body, 'hello\n\nProgress: 15%');
       done();
     });
 });
 
 QUnit.test('create warns if an unsupported type is given', function(assert) {
   var done = assert.async();
   var warn = sandbox.stub(console, 'warn');
   chrome.notifications.create({'type': 'faketype'}, function() {
     assert.ok(warn.calledOnce);
     assert.equal(warn.args[0].join(' '),
         'Notification type faketype not supported. Falling back to basic.');
     done();
   });
 });
 
 QUnit.test('creates a notification with the correct icon',function(assert) {
     var done = assert.async();
+    var showNotification = this.showNotification;
     chrome.notifications.create({'type': 'basic', 'iconUrl': 'aURL'},
         function() {
-          assert.equal(Notification.args[0][1].icon, 'aURL');
+          var creator = Notification.called ? Notification : showNotification;
+          assert.equal(creator.args[0][1].icon, 'aURL');
           done();
         }
     );
 });
 
 QUnit.test('passes false to callback if no notification cleared',
     function(assert) {
       var done = assert.async();
       chrome.notifications.clear('thisiddoesnotexist', function(success) {
         assert.notOk(success);
@@ skipping 51 matching lines @@
 QUnit.test(
   'passes DENIED to callback if no permission set', function(assert) {
     Notification.permission = 'default';
     chrome.notifications.getPermissionLevel(function(level) {
       assert.equal(level, chrome.notifications.PermissionLevel.DENIED);
     });
   }
 );
 
 // TODO(alger): Add tests for onClicked event handler.