@imatis/react-native-notifications 4.3.3-imatis.11 → 4.3.3-imatis.12

package/lib/dist/NotificationsIOS.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsIOS = void 0;
+const react_native_1 = require("react-native");
+class NotificationsIOS {
+    commands;
+    eventsRegistry;
+    constructor(commands, eventsRegistry) {
+        this.commands = commands;
+        this.eventsRegistry = eventsRegistry;
+        return new Proxy(this, {
+            get(target, name) {
+                if (react_native_1.Platform.OS === 'ios') {
+                    return target[name];
+                }
+                else {
+                    return () => { };
+                }
+            }
+        });
+    }
+    /**
+    * Request permissions to send remote notifications
+    */
+    registerRemoteNotifications(options) {
+        return this.commands.requestPermissions(options);
+    }
+    /**
+    * Unregister for all remote notifications received via Apple Push Notification service
+    */
+    abandonPermissions() {
+        return this.commands.abandonPermissions();
+    }
+    /**
+   * registerPushKit
+   */
+    registerPushKit() {
+        return this.commands.registerPushKit();
+    }
+    /**
+     * getBadgeCount
+     */
+    getBadgeCount() {
+        return this.commands.getBadgeCount();
+    }
+    /**
+     * setBadgeCount
+     * @param count number of the new badge count
+     */
+    setBadgeCount(count) {
+        return this.commands.setBadgeCount(count);
+    }
+    /**
+     * cancelAllLocalNotifications
+     */
+    cancelAllLocalNotifications() {
+        this.commands.cancelAllLocalNotifications();
+    }
+    /**
+     * checkPermissions
+     */
+    checkPermissions() {
+        return this.commands.checkPermissions();
+    }
+    /**
+     * removeDeliveredNotifications
+     * @param identifiers Array of notification identifiers
+     */
+    removeDeliveredNotifications(identifiers) {
+        return this.commands.removeDeliveredNotifications(identifiers);
+    }
+    /**
+     * getDeliveredNotifications
+     */
+    getDeliveredNotifications() {
+        return this.commands.getDeliveredNotifications();
+    }
+    /**
+     * Obtain the events registry instance
+     */
+    events() {
+        return this.eventsRegistry;
+    }
+}
+exports.NotificationsIOS = NotificationsIOS;

package/lib/dist/adapters/CompletionCallbackWrapper.d.ts

@@ -0,0 +1,11 @@
+import { NativeCommandsSender } from './NativeCommandsSender';
+import { Notification } from "..";
+import { NotificationActionResponse } from '../interfaces/NotificationActionResponse';
+export declare class CompletionCallbackWrapper {
+    private readonly nativeCommandsSender;
+    constructor(nativeCommandsSender: NativeCommandsSender);
+    wrapReceivedBackgroundCallback(callback: Function): (notification: Notification) => void;
+    wrapReceivedForegroundCallback(callback: Function): (notification: Notification) => void;
+    private wrapReceivedAndInvoke;
+    wrapOpenedCallback(callback: Function): (notification: object, actionResponse?: NotificationActionResponse) => void;
+}

package/lib/dist/adapters/CompletionCallbackWrapper.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionCallbackWrapper = void 0;
+const react_native_1 = require("react-native");
+class CompletionCallbackWrapper {
+    nativeCommandsSender;
+    constructor(nativeCommandsSender) {
+        this.nativeCommandsSender = nativeCommandsSender;
+    }
+    wrapReceivedBackgroundCallback(callback) {
+        return (notification) => {
+            this.wrapReceivedAndInvoke(callback, notification, true);
+        };
+    }
+    wrapReceivedForegroundCallback(callback) {
+        return (notification) => {
+            this.wrapReceivedAndInvoke(callback, notification, false);
+        };
+    }
+    wrapReceivedAndInvoke(callback, notification, background) {
+        const completion = (response) => {
+            if (react_native_1.Platform.OS === 'ios') {
+                const identifier = notification.identifier;
+                if (background) {
+                    this.nativeCommandsSender.finishHandlingBackgroundAction(identifier, response);
+                }
+                else {
+                    this.nativeCommandsSender.finishPresentingNotification(identifier, response);
+                }
+            }
+        };
+        callback(notification, completion);
+    }
+    wrapOpenedCallback(callback) {
+        return (notification, actionResponse) => {
+            const completion = () => {
+                if (react_native_1.Platform.OS === 'ios') {
+                    this.nativeCommandsSender.finishHandlingAction(notification.identifier);
+                }
+            };
+            callback(notification, completion, actionResponse);
+        };
+    }
+}
+exports.CompletionCallbackWrapper = CompletionCallbackWrapper;

package/lib/dist/adapters/NativeCommandsSender.d.ts

@@ -0,0 +1,31 @@
+import { Notification } from '../DTO/Notification';
+import { NotificationCompletion } from '../interfaces/NotificationCompletion';
+import { NotificationPermissions } from '../interfaces/NotificationPermissions';
+import { NotificationCategory } from '../interfaces/NotificationCategory';
+import { NotificationChannel } from '../interfaces/NotificationChannel';
+import { NotificationPermissionOptions } from '../interfaces/NotificationPermissions';
+export declare class NativeCommandsSender {
+    private readonly nativeCommandsModule;
+    constructor();
+    postLocalNotification(notification: Notification, id: number): void;
+    getInitialNotification(): Promise<Object>;
+    getLastAction(): Promise<Object>;
+    requestPermissions(options?: NotificationPermissionOptions): void;
+    abandonPermissions(): void;
+    refreshToken(): void;
+    registerPushKit(): void;
+    setCategories(categories: [NotificationCategory?]): void;
+    getBadgeCount(): Promise<number>;
+    setBadgeCount(count: number): void;
+    cancelLocalNotification(notificationId: number): void;
+    cancelAllLocalNotifications(): void;
+    isRegisteredForRemoteNotifications(): Promise<any>;
+    checkPermissions(): Promise<NotificationPermissions>;
+    removeAllDeliveredNotifications(): void;
+    removeDeliveredNotifications(identifiers: Array<string>): void;
+    getDeliveredNotifications(): Promise<Notification[]>;
+    finishPresentingNotification(notificationId: string, notificationCompletion: NotificationCompletion): void;
+    finishHandlingAction(notificationId: string): void;
+    setNotificationChannel(notificationChannel: NotificationChannel): void;
+    finishHandlingBackgroundAction(notificationId: string, backgroundFetchResult: string): void;
+}

package/lib/dist/adapters/NativeCommandsSender.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeCommandsSender = void 0;
+const react_native_1 = require("react-native");
+class NativeCommandsSender {
+    nativeCommandsModule;
+    constructor() {
+        this.nativeCommandsModule = react_native_1.NativeModules.RNBridgeModule;
+    }
+    postLocalNotification(notification, id) {
+        return this.nativeCommandsModule.postLocalNotification(notification, id);
+    }
+    getInitialNotification() {
+        return this.nativeCommandsModule.getInitialNotification();
+    }
+    getLastAction() {
+        return this.nativeCommandsModule.getLastAction();
+    }
+    requestPermissions(options) {
+        return this.nativeCommandsModule.requestPermissions(options || {});
+    }
+    abandonPermissions() {
+        return this.nativeCommandsModule.abandonPermissions();
+    }
+    refreshToken() {
+        this.nativeCommandsModule.refreshToken();
+    }
+    registerPushKit() {
+        return this.nativeCommandsModule.registerPushKit();
+    }
+    setCategories(categories) {
+        this.nativeCommandsModule.setCategories(categories);
+    }
+    getBadgeCount() {
+        return this.nativeCommandsModule.getBadgeCount();
+    }
+    setBadgeCount(count) {
+        this.nativeCommandsModule.setBadgeCount(count);
+    }
+    cancelLocalNotification(notificationId) {
+        this.nativeCommandsModule.cancelLocalNotification(notificationId);
+    }
+    cancelAllLocalNotifications() {
+        this.nativeCommandsModule.cancelAllLocalNotifications();
+    }
+    isRegisteredForRemoteNotifications() {
+        return this.nativeCommandsModule.isRegisteredForRemoteNotifications();
+    }
+    checkPermissions() {
+        return this.nativeCommandsModule.checkPermissions();
+    }
+    removeAllDeliveredNotifications() {
+        return this.nativeCommandsModule.removeAllDeliveredNotifications();
+    }
+    removeDeliveredNotifications(identifiers) {
+        return this.nativeCommandsModule.removeDeliveredNotifications(identifiers);
+    }
+    getDeliveredNotifications() {
+        return this.nativeCommandsModule.getDeliveredNotifications();
+    }
+    finishPresentingNotification(notificationId, notificationCompletion) {
+        this.nativeCommandsModule.finishPresentingNotification(notificationId, notificationCompletion);
+    }
+    finishHandlingAction(notificationId) {
+        this.nativeCommandsModule.finishHandlingAction(notificationId);
+    }
+    setNotificationChannel(notificationChannel) {
+        this.nativeCommandsModule.setNotificationChannel(notificationChannel);
+    }
+    finishHandlingBackgroundAction(notificationId, backgroundFetchResult) {
+        this.nativeCommandsModule.finishHandlingBackgroundAction(notificationId, backgroundFetchResult);
+    }
+}
+exports.NativeCommandsSender = NativeCommandsSender;

package/lib/dist/adapters/NativeEventsReceiver.d.ts

@@ -0,0 +1,19 @@
+import { EmitterSubscription } from 'react-native';
+import { Registered, RegistrationError, RegisteredPushKit } from '../interfaces/NotificationEvents';
+import { Notification } from '../DTO/Notification';
+import { NotificationActionResponse } from '../interfaces/NotificationActionResponse';
+import { NotificationFactory } from '../DTO/NotificationFactory';
+export declare class NativeEventsReceiver {
+    private readonly notificationFactory;
+    private emitter;
+    constructor(notificationFactory?: NotificationFactory);
+    registerRemoteNotificationsRegistered(callback: (event: Registered) => void): EmitterSubscription;
+    appNotificationSettingsLinked(callback: () => void): EmitterSubscription;
+    registerPushKitRegistered(callback: (event: RegisteredPushKit) => void): EmitterSubscription;
+    registerNotificationReceived(callback: (notification: Notification) => void): EmitterSubscription;
+    registerNotificationReceivedBackground(callback: (notification: Notification) => void): EmitterSubscription;
+    registerPushKitNotificationReceived(callback: (event: object) => void): EmitterSubscription;
+    registerNotificationOpened(callback: (notification: Notification, actionResponse?: NotificationActionResponse) => void): EmitterSubscription;
+    registerRemoteNotificationsRegistrationFailed(callback: (event: RegistrationError) => void): EmitterSubscription;
+    registerRemoteNotificationsRegistrationDenied(callback: () => void): EmitterSubscription;
+}

package/lib/dist/adapters/NativeEventsReceiver.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeEventsReceiver = void 0;
+const react_native_1 = require("react-native");
+const NotificationActionResponse_1 = require("../interfaces/NotificationActionResponse");
+const NotificationFactory_1 = require("../DTO/NotificationFactory");
+class NativeEventsReceiver {
+    notificationFactory;
+    emitter;
+    constructor(notificationFactory = new NotificationFactory_1.NotificationFactory()) {
+        this.notificationFactory = notificationFactory;
+        this.emitter = new react_native_1.NativeEventEmitter(react_native_1.NativeModules.RNEventEmitter);
+    }
+    registerRemoteNotificationsRegistered(callback) {
+        return this.emitter.addListener('remoteNotificationsRegistered', callback);
+    }
+    appNotificationSettingsLinked(callback) {
+        return this.emitter.addListener('appNotificationSettingsLinked', callback);
+    }
+    registerPushKitRegistered(callback) {
+        return this.emitter.addListener('pushKitRegistered', callback);
+    }
+    registerNotificationReceived(callback) {
+        return this.emitter.addListener('notificationReceived', (payload) => {
+            callback(this.notificationFactory.fromPayload(payload));
+        });
+    }
+    registerNotificationReceivedBackground(callback) {
+        return this.emitter.addListener('notificationReceivedBackground', (payload) => {
+            callback(this.notificationFactory.fromPayload(payload));
+        });
+    }
+    registerPushKitNotificationReceived(callback) {
+        return this.emitter.addListener('pushKitNotificationReceived', callback);
+    }
+    registerNotificationOpened(callback) {
+        return this.emitter.addListener('notificationOpened', (response) => {
+            const action = response.action ? new NotificationActionResponse_1.NotificationActionResponse(response.action) : undefined;
+            callback(this.notificationFactory.fromPayload(response.notification), action);
+        });
+    }
+    registerRemoteNotificationsRegistrationFailed(callback) {
+        return this.emitter.addListener('remoteNotificationsRegistrationFailed', callback);
+    }
+    registerRemoteNotificationsRegistrationDenied(callback) {
+        return this.emitter.addListener('remoteNotificationsRegistrationDenied', callback);
+    }
+}
+exports.NativeEventsReceiver = NativeEventsReceiver;

package/lib/dist/adapters/UniqueIdProvider.d.ts

@@ -0,0 +1,3 @@
+export declare class UniqueIdProvider {
+    generate(): number;
+}

package/lib/dist/adapters/UniqueIdProvider.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueIdProvider = void 0;
+const _ = require("lodash");
+class UniqueIdProvider {
+    generate() {
+        return parseInt(_.uniqueId());
+    }
+}
+exports.UniqueIdProvider = UniqueIdProvider;

package/lib/dist/commands/Commands.d.ts

@@ -0,0 +1,32 @@
+import { NativeCommandsSender } from '../adapters/NativeCommandsSender';
+import { Notification } from '../DTO/Notification';
+import { NotificationCategory } from '../interfaces/NotificationCategory';
+import { NotificationChannel } from '../interfaces/NotificationChannel';
+import { NotificationPermissions } from '../interfaces/NotificationPermissions';
+import { UniqueIdProvider } from '../adapters/UniqueIdProvider';
+import { NotificationFactory } from '../DTO/NotificationFactory';
+import { NotificationPermissionOptions } from '../interfaces/NotificationPermissions';
+export declare class Commands {
+    private readonly nativeCommandsSender;
+    private readonly uniqueIdProvider;
+    private readonly notificationFactory;
+    constructor(nativeCommandsSender: NativeCommandsSender, uniqueIdProvider: UniqueIdProvider, notificationFactory: NotificationFactory);
+    postLocalNotification(notification: Notification, id?: number): number;
+    getInitialNotification(): Promise<Notification | undefined>;
+    getLastAction(): Promise<Notification | undefined>;
+    requestPermissions(options?: NotificationPermissionOptions): void;
+    abandonPermissions(): void;
+    registerPushKit(): void;
+    setCategories(categories: [NotificationCategory?]): void;
+    getBadgeCount(): Promise<number>;
+    setBadgeCount(count: number): void;
+    cancelLocalNotification(notificationId: number): void;
+    cancelAllLocalNotifications(): void;
+    isRegisteredForRemoteNotifications(): Promise<boolean>;
+    checkPermissions(): Promise<NotificationPermissions>;
+    removeAllDeliveredNotifications(): void;
+    removeDeliveredNotifications(identifiers: Array<string>): void;
+    getDeliveredNotifications(): Promise<Notification[]>;
+    refreshToken(): void;
+    setNotificationChannel(notificationChannel: NotificationChannel): void;
+}

package/lib/dist/commands/Commands.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commands = void 0;
+class Commands {
+    nativeCommandsSender;
+    uniqueIdProvider;
+    notificationFactory;
+    constructor(nativeCommandsSender, uniqueIdProvider, notificationFactory) {
+        this.nativeCommandsSender = nativeCommandsSender;
+        this.uniqueIdProvider = uniqueIdProvider;
+        this.notificationFactory = notificationFactory;
+    }
+    postLocalNotification(notification, id) {
+        const notificationId = id ? id : this.uniqueIdProvider.generate();
+        this.nativeCommandsSender.postLocalNotification(notification, notificationId);
+        return notificationId;
+    }
+    async getInitialNotification() {
+        return this.nativeCommandsSender.getInitialNotification().then((payload) => {
+            if (payload) {
+                return this.notificationFactory.fromPayload(payload);
+            }
+            return undefined;
+        });
+    }
+    async getLastAction() {
+        return this.nativeCommandsSender.getLastAction().then((payload) => {
+            if (payload) {
+                return this.notificationFactory.fromPayload(payload);
+            }
+            return undefined;
+        });
+    }
+    requestPermissions(options) {
+        const result = this.nativeCommandsSender.requestPermissions(options);
+        return result;
+    }
+    abandonPermissions() {
+        const result = this.nativeCommandsSender.abandonPermissions();
+        return result;
+    }
+    registerPushKit() {
+        this.nativeCommandsSender.registerPushKit();
+    }
+    setCategories(categories) {
+        this.nativeCommandsSender.setCategories(categories);
+    }
+    getBadgeCount() {
+        return this.nativeCommandsSender.getBadgeCount();
+    }
+    setBadgeCount(count) {
+        this.nativeCommandsSender.setBadgeCount(count);
+    }
+    cancelLocalNotification(notificationId) {
+        this.nativeCommandsSender.cancelLocalNotification(notificationId);
+    }
+    cancelAllLocalNotifications() {
+        this.nativeCommandsSender.cancelAllLocalNotifications();
+    }
+    isRegisteredForRemoteNotifications() {
+        return this.nativeCommandsSender.isRegisteredForRemoteNotifications();
+    }
+    checkPermissions() {
+        return this.nativeCommandsSender.checkPermissions();
+    }
+    removeAllDeliveredNotifications() {
+        this.nativeCommandsSender.removeAllDeliveredNotifications();
+    }
+    removeDeliveredNotifications(identifiers) {
+        return this.nativeCommandsSender.removeDeliveredNotifications(identifiers);
+    }
+    getDeliveredNotifications() {
+        return this.nativeCommandsSender.getDeliveredNotifications();
+    }
+    refreshToken() {
+        this.nativeCommandsSender.refreshToken();
+    }
+    setNotificationChannel(notificationChannel) {
+        this.nativeCommandsSender.setNotificationChannel(notificationChannel);
+    }
+}
+exports.Commands = Commands;

package/lib/dist/commands/Commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/commands/Commands.test.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts_mockito_1 = require("ts-mockito");
+const Commands_1 = require("./Commands");
+const NativeCommandsSender_1 = require("../adapters/NativeCommandsSender");
+const Notification_1 = require("../DTO/Notification");
+const UniqueIdProvider_1 = require("../adapters/UniqueIdProvider");
+const NotificationFactory_1 = require("../DTO/NotificationFactory");
+const NotificationAndroid_1 = require("../DTO/NotificationAndroid");
+const react_native_1 = require("react-native");
+const NotificationIOS_1 = require("../DTO/NotificationIOS");
+describe('Commands', () => {
+    let uut;
+    let mockedNativeCommandsSender;
+    let mockedUniqueIdProvider;
+    let notificationFactory;
+    beforeEach(() => {
+        notificationFactory = new NotificationFactory_1.NotificationFactory();
+        mockedNativeCommandsSender = (0, ts_mockito_1.mock)(NativeCommandsSender_1.NativeCommandsSender);
+        mockedUniqueIdProvider = (0, ts_mockito_1.mock)(UniqueIdProvider_1.UniqueIdProvider);
+        (0, ts_mockito_1.when)(mockedUniqueIdProvider.generate()).thenCall(() => 12);
+        uut = new Commands_1.Commands((0, ts_mockito_1.instance)(mockedNativeCommandsSender), (0, ts_mockito_1.instance)(mockedUniqueIdProvider), notificationFactory);
+    });
+    describe('getInitialNotification', () => {
+        it('sends to native', () => {
+            uut.getInitialNotification();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.getInitialNotification()).called();
+        });
+        it('Android - returns a promise with the initial notification', async () => {
+            react_native_1.Platform.OS = 'android';
+            const expectedNotification = new NotificationAndroid_1.NotificationAndroid({ 'google.message_id': 'id' });
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.getInitialNotification()).thenResolve({ 'google.message_id': 'id' });
+            const result = await uut.getInitialNotification();
+            expect(result).toEqual(expectedNotification);
+        });
+        it('Should return undefined initial notification', async () => {
+            react_native_1.Platform.OS = 'android';
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.getInitialNotification()).thenResolve();
+            const result = await uut.getInitialNotification();
+            expect(result).toEqual(undefined);
+        });
+        it('iOS - returns a promise with the initial notification', async () => {
+            react_native_1.Platform.OS = 'ios';
+            const expectedNotification = new NotificationIOS_1.NotificationIOS({ identifier: 'id' });
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.getInitialNotification()).thenResolve({ identifier: 'id' });
+            const result = await uut.getInitialNotification();
+            expect(result).toEqual(expectedNotification);
+        });
+    });
+    describe('requestPermissions', () => {
+        it('sends to native', () => {
+            const opts = {};
+            uut.requestPermissions(opts);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.requestPermissions(opts)).called();
+        });
+        it('sends to native with options', () => {
+            const opts = { criticalAlert: true };
+            uut.requestPermissions(opts);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.requestPermissions(opts)).called();
+        });
+    });
+    describe('registerPushKit', () => {
+        it('sends to native', () => {
+            uut.registerPushKit();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.registerPushKit()).called();
+        });
+    });
+    describe('setCategories', () => {
+        it('sends to native', () => {
+            const emptyCategoriesArray = [];
+            uut.setCategories(emptyCategoriesArray);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.setCategories(emptyCategoriesArray)).called();
+        });
+        it('sends to native with categories', () => {
+            const category = { identifier: 'id', actions: [] };
+            const categoriesArray = [category];
+            uut.setCategories(categoriesArray);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.setCategories(categoriesArray)).called();
+        });
+    });
+    describe('abandonPermissions', () => {
+        it('sends to native', () => {
+            uut.abandonPermissions();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.abandonPermissions()).called();
+        });
+    });
+    describe('postLocalNotification', () => {
+        it('sends to native', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            uut.postLocalNotification(notification);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.postLocalNotification(notification, (0, ts_mockito_1.anyNumber)())).called();
+        });
+        it('generates unique identifier', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            uut.postLocalNotification(notification);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.postLocalNotification(notification, (0, ts_mockito_1.anyNumber)())).called();
+        });
+        it('use passed notification id', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            const passedId = 2;
+            uut.postLocalNotification(notification, passedId);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.postLocalNotification(notification, passedId)).called();
+        });
+        it('return notification id', () => {
+            const notification = new Notification_1.Notification({ identifier: 'id' });
+            const notificationId = 2;
+            const response = uut.postLocalNotification(notification, notificationId);
+            expect(response).toEqual(notificationId);
+        });
+    });
+    describe('getBadgeCount', () => {
+        it('sends to native', () => {
+            uut.getBadgeCount();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.getBadgeCount()).called();
+        });
+    });
+    describe('setBadgeCount', () => {
+        it('sends to native', () => {
+            uut.setBadgeCount(10);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.setBadgeCount(10)).called();
+        });
+    });
+    describe('cancelLocalNotification', () => {
+        it('sends to native', () => {
+            const notificationId = 1;
+            uut.cancelLocalNotification(notificationId);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.cancelLocalNotification(notificationId)).called();
+        });
+    });
+    describe('cancelAllLocalNotifications', () => {
+        it('sends to native', () => {
+            uut.cancelAllLocalNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.cancelAllLocalNotifications()).called();
+        });
+    });
+    describe('isRegisteredForRemoteNotifications', () => {
+        it('sends to native', () => {
+            uut.isRegisteredForRemoteNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).called();
+        });
+        it('return positive response from native', async () => {
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).thenResolve(true);
+            const isRegistered = await uut.isRegisteredForRemoteNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).called();
+            expect(isRegistered).toEqual(true);
+        });
+        it('return negative response from native', async () => {
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.isRegisteredForRemoteNotifications()).thenResolve(false);
+            const isRegistered = await uut.isRegisteredForRemoteNotifications();
+            expect(isRegistered).toEqual(false);
+        });
+    });
+    describe('checkPermissions', () => {
+        it('sends to native', () => {
+            uut.checkPermissions();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.checkPermissions()).called();
+        });
+        it('return negative response from native', async () => {
+            const expectedPermissions = {
+                badge: false,
+                alert: true,
+                sound: false,
+                carPlay: false,
+                criticalAlert: false,
+                providesAppNotificationSettings: false,
+                provisional: false,
+                announcement: false,
+                notificationCenter: true,
+                lockScreen: false,
+            };
+            (0, ts_mockito_1.when)(mockedNativeCommandsSender.checkPermissions()).thenResolve(expectedPermissions);
+            const permissions = await uut.checkPermissions();
+            expect(permissions).toEqual(expectedPermissions);
+        });
+    });
+    describe('removeAllDeliveredNotifications', () => {
+        it('sends to native', () => {
+            uut.removeAllDeliveredNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.removeAllDeliveredNotifications()).called();
+        });
+    });
+    describe('removeDeliveredNotifications', () => {
+        it('sends to native', () => {
+            const identifiers = ["id1", "id2"];
+            uut.removeDeliveredNotifications(identifiers);
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.removeDeliveredNotifications(identifiers)).called();
+        });
+    });
+    describe('getDeliveredNotifications', () => {
+        it('sends to native', () => {
+            uut.getDeliveredNotifications();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.getDeliveredNotifications()).called();
+        });
+    });
+    describe('refreshToken', () => {
+        it('sends to native', () => {
+            uut.refreshToken();
+            (0, ts_mockito_1.verify)(mockedNativeCommandsSender.refreshToken()).called();
+        });
+    });
+});