From d7697c11b5f2b811b6add58497658cd8717f8a68 Mon Sep 17 00:00:00 2001 From: d4vidi Date: Wed, 23 Nov 2016 11:36:49 +0200 Subject: [PATCH] Add JS-lib unit tests (Android) --- index.android.js | 38 ++++---- test/index.android.spec.js | 190 +++++++++++++++++++++++++++++++++++++ 2 files changed, 210 insertions(+), 18 deletions(-) create mode 100644 test/index.android.spec.js diff --git a/index.android.js b/index.android.js index 02dd5b0..f78dc23 100644 --- a/index.android.js +++ b/index.android.js @@ -8,26 +8,10 @@ let notificationOpenedListener; let registrationTokenUpdateListener; export class NotificationsAndroid { - static setRegistrationTokenUpdateListener(listener) { - registrationTokenUpdateListener = DeviceEventEmitter.addListener("remoteNotificationsRegistered", listener); - } - - static clearRegistrationTokenUpdateListener() { - if (registrationTokenUpdateListener) { - registrationTokenUpdateListener.remove(); - registrationTokenUpdateListener = null; - } - } - static setNotificationOpenedListener(listener) { notificationOpenedListener = DeviceEventEmitter.addListener("notificationOpened", (notification) => listener(new NotificationAndroid(notification))); } - - static setNotificationReceivedListener(listener) { - notificationReceivedListener = DeviceEventEmitter.addListener("notificationReceived", (notification) => listener(new NotificationAndroid(notification))); - } - static clearNotificationOpenedListener() { if (notificationOpenedListener) { notificationOpenedListener.remove(); @@ -35,6 +19,10 @@ export class NotificationsAndroid { } } + static setNotificationReceivedListener(listener) { + notificationReceivedListener = DeviceEventEmitter.addListener("notificationReceived", (notification) => listener(new NotificationAndroid(notification))); + } + static clearNotificationReceivedListener() { if (notificationReceivedListener) { notificationReceivedListener.remove(); @@ -42,13 +30,27 @@ export class NotificationsAndroid { } } + static setRegistrationTokenUpdateListener(listener) { + registrationTokenUpdateListener = DeviceEventEmitter.addListener("remoteNotificationsRegistered", listener); + } + + static clearRegistrationTokenUpdateListener() { + if (registrationTokenUpdateListener) { + registrationTokenUpdateListener.remove(); + registrationTokenUpdateListener = null; + } + } + static refreshToken() { RNNotifications.refreshToken(); } } export class PendingNotifications { - static async getInitialNotification() { - return new NotificationAndroid(await RNNotifications.getInitialNotification()); + static getInitialNotification() { + return RNNotifications.getInitialNotification() + .then((rawNotification) => { + return new NotificationAndroid(rawNotification); + }); } } diff --git a/test/index.android.spec.js b/test/index.android.spec.js new file mode 100644 index 0000000..4462924 --- /dev/null +++ b/test/index.android.spec.js @@ -0,0 +1,190 @@ +"use strict"; +let expect = require("chai").use(require("sinon-chai")).expect; +import proxyquire from "proxyquire"; +import sinon from "sinon"; + +describe("Notifications-Android", () => { + proxyquire.noCallThru(); + + let refreshTokenStub; + let getInitialNotificationStub; + let deviceEventEmitterListenerStub; + let libUnderTest; + beforeEach(() => { + refreshTokenStub = sinon.stub(); + getInitialNotificationStub = sinon.stub(); + deviceEventEmitterListenerStub = sinon.stub(); + + libUnderTest = proxyquire("../index.android", { + "react-native": { + NativeModules: { + WixRNNotifications: { + refreshToken: refreshTokenStub, + getInitialNotification: getInitialNotificationStub + } + }, + DeviceEventEmitter: { + addListener: deviceEventEmitterListenerStub + } + }, + "./notification": require("../notification.android") + }); + }); + + describe("Registration token API", () => { + it("should assign callback to native event upon listener registration", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListener = () => {}; + + libUnderTest.NotificationsAndroid.setRegistrationTokenUpdateListener(userListener); + + expect(deviceEventEmitterListenerStub).to.have.been.calledWith("remoteNotificationsRegistered", userListener); + expect(deviceEventEmitterListenerStub).to.have.been.calledOnce; + }); + + it("should clear native event listener upon listener deregister", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListener = () => {}; + const nativeListener = { + remove: sinon.spy() + }; + deviceEventEmitterListenerStub.returns(nativeListener); + + libUnderTest.NotificationsAndroid.setRegistrationTokenUpdateListener(userListener); + libUnderTest.NotificationsAndroid.clearRegistrationTokenUpdateListener(); + + expect(nativeListener.remove).to.have.been.calledOnce; + }); + + it("shouldn't fail if deregister without registering", () => { + libUnderTest.NotificationsAndroid.clearRegistrationTokenUpdateListener(); + + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + }); + }); + + describe("notification-opening API", () => { + it("should assign callback to native event upon registration", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListenerStub = sinon.stub(); + + libUnderTest.NotificationsAndroid.setNotificationOpenedListener(userListenerStub); + + expect(deviceEventEmitterListenerStub).to.have.been.calledOnce; + expect(deviceEventEmitterListenerStub).to.have.been.calledWith("notificationOpened", sinon.match.func); + }); + + it("should assign a wrapper-callback upon registration", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListenerStub = sinon.stub(); + const notification = { foo: "bar" }; + + libUnderTest.NotificationsAndroid.setNotificationOpenedListener(userListenerStub); + + expect(userListenerStub).to.not.have.been.called; + deviceEventEmitterListenerStub.args[0][1](notification); + expect(userListenerStub).to.have.been.calledOnce; + expect(userListenerStub.args[0][0].getData()).to.equal(notification); + }); + + it("should clear native event listener upon listener deregister", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListener = () => {}; + const nativeListener = { + remove: sinon.spy() + }; + deviceEventEmitterListenerStub.returns(nativeListener); + + libUnderTest.NotificationsAndroid.setNotificationOpenedListener(userListener); + libUnderTest.NotificationsAndroid.clearNotificationOpenedListener(); + + expect(nativeListener.remove).to.have.been.calledOnce; + }); + + it("shouldn't fail if deregister without registering", () => { + libUnderTest.NotificationsAndroid.clearNotificationOpenedListener(); + + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + }); + }); + + describe("notification-receive API", () => { + it("should assign callback to native event upon registration", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListenerStub = sinon.stub(); + + libUnderTest.NotificationsAndroid.setNotificationReceivedListener(userListenerStub); + + expect(deviceEventEmitterListenerStub).to.have.been.calledOnce; + expect(deviceEventEmitterListenerStub).to.have.been.calledWith("notificationReceived", sinon.match.func); + }); + + it("should assign a wrapper-callback upon registration", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListenerStub = sinon.stub(); + const notification = { foo: "bar" }; + + libUnderTest.NotificationsAndroid.setNotificationReceivedListener(userListenerStub); + + expect(userListenerStub).to.not.have.been.called; + deviceEventEmitterListenerStub.args[0][1](notification); + expect(userListenerStub).to.have.been.calledOnce; + expect(userListenerStub.args[0][0].getData()).to.equal(notification); + }); + + it("should clear native event listener upon listener deregister", () => { + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + const userListener = () => {}; + const nativeListener = { + remove: sinon.spy() + }; + deviceEventEmitterListenerStub.returns(nativeListener); + + libUnderTest.NotificationsAndroid.setNotificationReceivedListener(userListener); + libUnderTest.NotificationsAndroid.clearNotificationReceivedListener(); + + expect(nativeListener.remove).to.have.been.calledOnce; + }); + + it("shouldn't fail if deregister without registering", () => { + libUnderTest.NotificationsAndroid.clearNotificationReceivedListener(); + + expect(deviceEventEmitterListenerStub).to.not.have.been.called; + }); + }); + + it("should refresh notification token upon refreshing request by the user", () => { + expect(refreshTokenStub).to.not.have.been.called; + libUnderTest.NotificationsAndroid.refreshToken(); + expect(refreshTokenStub).to.have.been.calledOnce; + }); + + describe("Initial notification API", () => { + it("should return initial notification data if available", (done) => { + expect(getInitialNotificationStub).to.not.have.been.called; + const rawNotification = {foo: "bar"}; + getInitialNotificationStub.returns(Promise.resolve(rawNotification)); + + libUnderTest.PendingNotifications.getInitialNotification() + .then((notification) => { + expect(notification.getData()).to.equal(rawNotification); + done(); + }) + .catch((err) => done(err)); + }); + + it("should return empty notification data if not available", (done) => { + expect(getInitialNotificationStub).to.not.have.been.called; + getInitialNotificationStub.returns(Promise.resolve(null)); + + libUnderTest.PendingNotifications.getInitialNotification() + .then((notification) => { + expect(notification.getData()).to.equal(null); + done(); + }) + .catch((err) => done(err)); + }); + + }); + +}); -- 2.26.2