Add support for push

spec/APNS.spec.js

@@ -1,6 +1,65 @@
 var APNS = require('../src/APNS');
 
 describe('APNS', () => {
+
+  it('can initialize with single cert', (done) => {
+    var args = {
+      cert: 'prodCert.pem',
+      key: 'prodKey.pem',
+      production: true,
+      bundleId: 'bundleId'
+    }
+    var apns = new APNS(args);
+
+    expect(apns.conns.length).toBe(1);
+    var apnsConnection = apns.conns[0];
+    expect(apnsConnection.index).toBe(0);
+    expect(apnsConnection.bundleId).toBe(args.bundleId);
+    // TODO: Remove this checking onec we inject APNS
+    var prodApnsOptions = apnsConnection.options;
+    expect(prodApnsOptions.cert).toBe(args.cert);
+    expect(prodApnsOptions.key).toBe(args.key);
+    expect(prodApnsOptions.production).toBe(args.production);
+    done();
+  });
+
+  it('can initialize with multiple certs', (done) => {
+    var args = [
+      {
+        cert: 'devCert.pem',
+        key: 'devKey.pem',
+        production: false,
+        bundleId: 'bundleId'
+      },
+      {
+        cert: 'prodCert.pem',
+        key: 'prodKey.pem',
+        production: true,
+        bundleId: 'bundleIdAgain'
+      }
+    ]
+
+    var apns = new APNS(args);
+    expect(apns.conns.length).toBe(2);
+    var devApnsConnection = apns.conns[1];
+    expect(devApnsConnection.index).toBe(1);
+    var devApnsOptions = devApnsConnection.options;
+    expect(devApnsOptions.cert).toBe(args[0].cert);
+    expect(devApnsOptions.key).toBe(args[0].key);
+    expect(devApnsOptions.production).toBe(args[0].production);
+    expect(devApnsConnection.bundleId).toBe(args[0].bundleId);
+
+    var prodApnsConnection = apns.conns[0];
+    expect(prodApnsConnection.index).toBe(0);
+    // TODO: Remove this checking onec we inject APNS
+    var prodApnsOptions = prodApnsConnection.options;
+    expect(prodApnsOptions.cert).toBe(args[1].cert);
+    expect(prodApnsOptions.key).toBe(args[1].key);
+    expect(prodApnsOptions.production).toBe(args[1].production);
+    expect(prodApnsOptions.bundleId).toBe(args[1].bundleId);
+    done();
+  });
+
   it('can generate APNS notification', (done) => {
     //Mock request data
     var data = {
@@ -29,12 +88,195 @@ describe('APNS', () => {
     done();
   });
 
+  it('can choose conns for device without appIdentifier', (done) => {
+    // Mock conns
+    var conns = [
+      {
+        bundleId: 'bundleId'
+      },
+      {
+        bundleId: 'bundleIdAgain'
+      }
+    ];
+    // Mock device
+    var device = {};
+
+    var qualifiedConns = APNS.chooseConns(conns, device);
+    expect(qualifiedConns).toEqual([0, 1]);
+    done();
+  });
+
+  it('can choose conns for device with valid appIdentifier', (done) => {
+    // Mock conns
+    var conns = [
+      {
+        bundleId: 'bundleId'
+      },
+      {
+        bundleId: 'bundleIdAgain'
+      }
+    ];
+    // Mock device
+    var device = {
+      appIdentifier: 'bundleId'
+    };
+
+    var qualifiedConns = APNS.chooseConns(conns, device);
+    expect(qualifiedConns).toEqual([0]);
+    done();
+  });
+
+  it('can choose conns for device with invalid appIdentifier', (done) => {
+    // Mock conns
+    var conns = [
+      {
+        bundleId: 'bundleId'
+      },
+      {
+        bundleId: 'bundleIdAgain'
+      }
+    ];
+    // Mock device
+    var device = {
+      appIdentifier: 'invalid'
+    };
+
+    var qualifiedConns = APNS.chooseConns(conns, device);
+    expect(qualifiedConns).toEqual([]);
+    done();
+  });
+
+  it('can handle transmission error when notification is not in cache or device is missing', (done) => {
+    // Mock conns
+    var conns = [];
+    var errorCode = 1;
+    var notification = undefined;
+    var device = {};
+
+    APNS.handleTransmissionError(conns, errorCode, notification, device);
+
+    var notification = {};
+    var device = undefined;
+
+    APNS.handleTransmissionError(conns, errorCode, notification, device);
+    done();
+  });
+
+  it('can handle transmission error when there are other qualified conns', (done) => {
+    // Mock conns
+    var conns = [
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId1'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId1'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId2'
+      },
+    ];
+    var errorCode = 1;
+    var notification = {};
+    var apnDevice = {
+      connIndex: 0,
+      appIdentifier: 'bundleId1'
+    };
+
+    APNS.handleTransmissionError(conns, errorCode, notification, apnDevice);
+
+    expect(conns[0].pushNotification).not.toHaveBeenCalled();
+    expect(conns[1].pushNotification).toHaveBeenCalled();
+    expect(conns[2].pushNotification).not.toHaveBeenCalled();
+    done();
+  });
+
+  it('can handle transmission error when there is no other qualified conns', (done) => {
+    // Mock conns
+    var conns = [
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId1'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId1'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId1'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId2'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId1'
+      }
+    ];
+    var errorCode = 1;
+    var notification = {};
+    var apnDevice = {
+      connIndex: 2,
+      appIdentifier: 'bundleId1'
+    };
+
+    APNS.handleTransmissionError(conns, errorCode, notification, apnDevice);
+
+    expect(conns[0].pushNotification).not.toHaveBeenCalled();
+    expect(conns[1].pushNotification).not.toHaveBeenCalled();
+    expect(conns[2].pushNotification).not.toHaveBeenCalled();
+    expect(conns[3].pushNotification).not.toHaveBeenCalled();
+    expect(conns[4].pushNotification).toHaveBeenCalled();
+    done();
+  });
+
+  it('can handle transmission error when device has no appIdentifier', (done) => {
+    // Mock conns
+    var conns = [
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId1'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId2'
+      },
+      {
+        pushNotification: jasmine.createSpy('pushNotification'),
+        bundleId: 'bundleId3'
+      },
+    ];
+    var errorCode = 1;
+    var notification = {};
+    var apnDevice = {
+      connIndex: 1,
+    };
+
+    APNS.handleTransmissionError(conns, errorCode, notification, apnDevice);
+
+    expect(conns[0].pushNotification).not.toHaveBeenCalled();
+    expect(conns[1].pushNotification).not.toHaveBeenCalled();
+    expect(conns[2].pushNotification).toHaveBeenCalled();
+    done();
+  });
+
   it('can send APNS notification', (done) => {
-    var apns = new APNS();
-    var sender = {
-      pushNotification: jasmine.createSpy('send')
+    var args = {
+      cert: 'prodCert.pem',
+      key: 'prodKey.pem',
+      production: true,
+      bundleId: 'bundleId'
+    }
+    var apns = new APNS(args);
+    var conn = {
+      pushNotification: jasmine.createSpy('send'),
+      bundleId: 'bundleId'
     };
-    apns.sender = sender;
+    apns.conns = [ conn ];
     // Mock data
     var expirationTime = 1454571491354
     var data = {
@@ -43,16 +285,23 @@ describe('APNS', () => {
         'alert': 'alert'
       }
     }
-    // Mock registrationTokens
-    var deviceTokens = ['token'];
+    // Mock devices
+    var devices = [
+      {
+        deviceToken: '112233',
+        appIdentifier: 'bundleId'
+      }
+    ];
 
-    var promise = apns.send(data, deviceTokens);
-    expect(sender.pushNotification).toHaveBeenCalled();
-    var args = sender.pushNotification.calls.first().args;
+    var promise = apns.send(data, devices);
+    expect(conn.pushNotification).toHaveBeenCalled();
+    var args = conn.pushNotification.calls.first().args;
     var notification = args[0];
     expect(notification.alert).toEqual(data.data.alert);
     expect(notification.expiry).toEqual(data['expiration_time']);
-    expect(args[1]).toEqual(deviceTokens);
+    var apnDevice = args[1]
+    expect(apnDevice.connIndex).toEqual(0);
+    expect(apnDevice.appIdentifier).toEqual('bundleId');
     done();
   });
 });

spec/GCM.spec.js

@@ -1,6 +1,23 @@
 var GCM = require('../src/GCM');
 
 describe('GCM', () => {
+  it('can initialize', (done) => {
+    var args = {
+      apiKey: 'apiKey'
+    };
+    var gcm = new GCM(args);
+    expect(gcm.sender.key).toBe(args.apiKey);
+    done();
+  });
+
+  it('can throw on initializing with invalid args', (done) => {
+    var args = 123
+    expect(function() {
+      new GCM(args);
+    }).toThrow();
+    done();
+  });
+
   it('can generate GCM Payload without expiration time', (done) => {
     //Mock request data
     var data = {
@@ -90,7 +107,9 @@ describe('GCM', () => {
   });
 
   it('can send GCM request', (done) => {
-    var gcm = new GCM('apiKey');
+    var gcm = new GCM({
+      apiKey: 'apiKey'
+    });
     // Mock gcm sender
     var sender = {
       send: jasmine.createSpy('send')
@@ -104,34 +123,37 @@ describe('GCM', () => {
         'alert': 'alert'
       }
     }
-    // Mock registrationTokens
-    var registrationTokens = ['token'];
+    // Mock devices
+    var devices = [
+      {
+        deviceToken: 'token'
+      }
+    ];
 
-    var promise = gcm.send(data, registrationTokens);
+    gcm.send(data, devices);
     expect(sender.send).toHaveBeenCalled();
     var args = sender.send.calls.first().args;
     // It is too hard to verify message of gcm library, we just verify tokens and retry times
-    expect(args[1].registrationTokens).toEqual(registrationTokens);
+    expect(args[1].registrationTokens).toEqual(['token']);
     expect(args[2]).toEqual(5);
     done();
   });
 
-  it('can throw on sending when we have too many registration tokens', (done) => {
-    var gcm = new GCM('apiKey');
-    // Mock gcm sender
-    var sender = {
-      send: jasmine.createSpy('send')
-    };
-    gcm.sender = sender;
-    // Mock registrationTokens
-    var registrationTokens = [];
-    for (var i = 0; i <= 2000; i++) {
-      registrationTokens.push(i.toString());
-    }
+  it('can slice devices', (done) => {
+    // Mock devices
+    var devices = [makeDevice(1), makeDevice(2), makeDevice(3), makeDevice(4)];
 
-    expect(function() {
-      gcm.send({}, registrationTokens);
-    }).toThrow();
+    var chunkDevices = GCM.sliceDevices(devices, 3);
+    expect(chunkDevices).toEqual([
+      [makeDevice(1), makeDevice(2), makeDevice(3)],
+      [makeDevice(4)]
+    ]);
     done();
   });
+
+  function makeDevice(deviceToken) {
+    return {
+      deviceToken: deviceToken
+    };
+  }
 });