softphone-vendor-headsets 2.0.0-develop.8 → 2.0.0-develop.9

package/dist/es/src/library/services/vendor-implementations/sennheiser/sennheiser.test.js

@@ -0,0 +1,680 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import SennheiserService from './sennheiser';
+import * as utils from '../../../utils';
+import { mockLogger, createMockWebSocket } from '../../../test-utils';
+import { SennheiserEvents, SennheiserEventTypes } from './types';
+describe('SennheiserService', () => {
+    let sennheiserService;
+    beforeEach(() => {
+        sennheiserService = SennheiserService.getInstance({ logger: console, createNew: true });
+        sennheiserService.logger = mockLogger;
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('instantiation', () => {
+        it('should be a singleton', () => {
+            const sennheiserService2 = SennheiserService.getInstance({ logger: console });
+            expect(sennheiserService).not.toBeFalsy();
+            expect(sennheiserService2).not.toBeFalsy();
+            expect(sennheiserService).toBe(sennheiserService2);
+        });
+        it('should have a connectTimeout value of 5000', () => {
+            expect(sennheiserService.connectTimeout).toBe(5000);
+        });
+    });
+    describe('deviceName', () => {
+        it('should return null if deviceInfo is null', () => {
+            sennheiserService.deviceInfo = null;
+            const result = sennheiserService.deviceName;
+            expect(result).toBeNull();
+        });
+        it('should return the name of the device if deviceInfo is not null', () => {
+            const ProductName = 'fake device';
+            sennheiserService.deviceInfo = { ProductName };
+            const result = sennheiserService.deviceName;
+            expect(result).toEqual(ProductName);
+        });
+    });
+    describe('isDeviceAttached', () => {
+        it('should return true if deviceInfo is defined', () => {
+            sennheiserService.deviceInfo = { ProductName: 'fakeDevice' };
+            const result = sennheiserService.isDeviceAttached;
+            expect(result).toBe(true);
+        });
+        it('should return false if deviceInfo is undefined or null', () => {
+            sennheiserService.deviceInfo = null;
+            expect(sennheiserService.isDeviceAttached).toBe(false);
+            sennheiserService.deviceInfo = undefined;
+            expect(sennheiserService.isDeviceAttached).toBe(false);
+        });
+    });
+    describe('deviceLabelMatchesVendor', () => {
+        it('should return true when the device label contains the string "sennheiser"', () => {
+            let testLabel = 'sennheiser headset';
+            let result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset SennHeiseR made';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset of Sennheiser';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+        });
+        it('should return false when the device label does not contain the string "sennheiser"', () => {
+            let testLabel = 'standard headset';
+            let result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset plantronics made';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset of awesome';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+        });
+        it('should return true when the device label contains the string "senn"', () => {
+            let testLabel = 'senn headset';
+            let result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset SeNN made';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset of Senn';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+        });
+        it('should return false when the device label does not contain the string "senn"', () => {
+            let testLabel = 'standard headset';
+            let result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset plantronics made';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset of awesome';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+        });
+        it('should return true when the device label contains the string "epos"', () => {
+            let testLabel = 'EPOS headset';
+            let result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset EpOs made';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset of ePoS';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+        });
+        it('should return false when the device label does not contain the string "epos"', () => {
+            let testLabel = 'standard headset';
+            let result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset plantronics made';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset of awesome';
+            result = sennheiserService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+        });
+    });
+    describe('disconnect', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should not call _sendMessage if the service is not connected', () => __awaiter(void 0, void 0, void 0, function* () {
+            sennheiserService.isConnected = false;
+            jest.spyOn(sennheiserService, '_sendMessage');
+            yield sennheiserService.disconnect();
+            expect(sennheiserService._sendMessage).not.toHaveBeenCalled();
+        }));
+        it('should call _sendMessage with the correct payload when the service is connected', () => __awaiter(void 0, void 0, void 0, function* () {
+            sennheiserService.isConnected = true;
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const expectedPayload = {
+                Event: SennheiserEvents.TerminateConnection,
+                EventType: SennheiserEventTypes.Request,
+            };
+            yield sennheiserService.disconnect();
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('setMute', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should call _sendMessage with a payload using SennheiserEvents.MuteFromApp when the value argument is defined', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const expectedPayload = {
+                Event: SennheiserEvents.MuteFromApp,
+                EventType: SennheiserEventTypes.Request,
+            };
+            yield sennheiserService.setMute(true);
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+        it('should call _sendMessage with a payload using SennheiserEvents.UnmuteFromApp when the value argument is defined', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const value = null;
+            const expectedPayload = {
+                Event: SennheiserEvents.UnmuteFromApp,
+                EventType: SennheiserEventTypes.Request,
+            };
+            yield sennheiserService.setMute(value);
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('setHold', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should call _sendMessage with a payload using SennheiserEvents.Hold when the value argument is defined', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const conversationId = '23f897b';
+            const expectedPayload = {
+                Event: SennheiserEvents.Hold,
+                EventType: SennheiserEventTypes.Request,
+                CallID: conversationId
+            };
+            yield sennheiserService.setHold(conversationId, true);
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+        it('should call _sendMessage with a payload using SennheiserEvents.Resume when the value argument is defined', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const value = null;
+            const conversationId = '23f897b';
+            const expectedPayload = {
+                Event: SennheiserEvents.Resume,
+                EventType: SennheiserEventTypes.Request,
+                CallID: conversationId
+            };
+            yield sennheiserService.setHold(conversationId, value);
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('incomingCall', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should call _sendMessage with a payload using SennheiserEvents.IncomingCall and the generated callId', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const callInfo = {
+                contactName: 'Ted Danson',
+                conversationId: '23f897b'
+            };
+            // Run Test
+            yield sennheiserService.incomingCall(callInfo);
+            // Get generated call mapping to create expected payload
+            // const generatedCallId = sennheiserService.callMappings[callInfo.conversationId];
+            const expectedPayload = {
+                Event: SennheiserEvents.IncomingCall,
+                EventType: SennheiserEventTypes.Request,
+                CallID: callInfo.conversationId
+            };
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('answerCall', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should call _sendMessage with a payload using SennheiserEvents.CallEnded', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const conversationId = '23f897b';
+            const expectedPayload = {
+                Event: SennheiserEvents.IncomingCallAccepted,
+                EventType: SennheiserEventTypes.Request,
+                CallID: conversationId,
+            };
+            yield sennheiserService.answerCall(conversationId);
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('rejectCall', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should call _sendMessage with a payload using SennheiserEvents.CallEnded', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const conversationId = '23f897b';
+            const expectedPayload = {
+                Event: SennheiserEvents.IncomingCallRejected,
+                EventType: SennheiserEventTypes.Request,
+                CallID: conversationId
+            };
+            yield sennheiserService.rejectCall(conversationId);
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('outgoingCall', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should call _sendMessage with a payload using SennheiserEvents.OutgoingCall', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const callInfo = {
+                contactName: 'Joe Fixit',
+                conversationId: '23f897b'
+            };
+            // Run Test
+            yield sennheiserService.outgoingCall(callInfo);
+            // Get generated call mapping to create expected payload
+            // const generatedCallId = sennheiserService.callMappings[callInfo.conversationId];
+            const expectedPayload = {
+                Event: SennheiserEvents.OutgoingCall,
+                EventType: SennheiserEventTypes.Request,
+                CallID: callInfo.conversationId
+            };
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('endCall', () => {
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+        });
+        it('should call _sendMessage with a payload using SennheiserEvents.CallEnded', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiserService, '_sendMessage');
+            const conversationId = '23f897b';
+            const expectedPayload = {
+                Event: SennheiserEvents.CallEnded,
+                EventType: SennheiserEventTypes.Request,
+                CallID: conversationId
+            };
+            yield sennheiserService.endCall(conversationId);
+            expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+        }));
+    });
+    describe('_handleMessage', () => {
+        let message;
+        beforeEach(() => {
+            sennheiserService.websocket = createMockWebSocket();
+            jest.spyOn(sennheiserService, '_handleAck');
+            jest.spyOn(sennheiserService, '_handleError');
+            jest.spyOn(sennheiserService, '_registerSoftphone');
+            sennheiserService._sendMessage = jest.fn();
+            jest.spyOn(sennheiserService, 'deviceAnsweredCall');
+            jest.spyOn(sennheiserService, 'deviceEndedCall');
+            jest.spyOn(sennheiserService, 'deviceHoldStatusChanged');
+            jest.spyOn(sennheiserService, 'deviceMuteChanged');
+            jest.spyOn(sennheiserService, 'deviceRejectedCall');
+        });
+        it('should call _handleError() if there is a ReturnCode in the message', () => {
+            message = { data: '{ "ReturnCode": 4 }' };
+            sennheiserService._handleMessage(message);
+            expect(sennheiserService._handleError).toHaveBeenCalledTimes(1);
+        });
+        it('should log an error if there is an error parsing the message', () => {
+            message = { data: '{"fail : "asdf" }' };
+            jest.spyOn(mockLogger, 'error');
+            sennheiserService._handleMessage(message);
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+        describe(`event type: ${SennheiserEvents.SocketConnected}`, () => {
+            it(`should call _registerSoftphone when the message event is '${SennheiserEvents.SocketConnected}'`, () => {
+                message = { data: `{ "Event": "${SennheiserEvents.SocketConnected}" }` };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._registerSoftphone).toHaveBeenCalledTimes(1);
+            });
+        });
+        describe(`event type: ${SennheiserEvents.EstablishConnection}`, () => {
+            it(`should call _sendMessage with the correct payload when the message event is '${SennheiserEvents.EstablishConnection}'`, () => {
+                message = { data: `{ "Event": "${SennheiserEvents.EstablishConnection}" }` };
+                const expectedPayload = {
+                    Event: SennheiserEvents.SPLogin,
+                    EventType: SennheiserEventTypes.Request,
+                };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._sendMessage).toHaveBeenCalledTimes(1);
+                expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+            });
+        });
+        describe(`event type: ${SennheiserEvents.SPLogin}`, () => {
+            beforeEach(() => {
+                message = { data: `{ "Event": "${SennheiserEvents.SPLogin}" }` };
+            });
+            it(`should call _sendMessage with the correct payload when the message event is '${SennheiserEvents.SPLogin}'`, () => {
+                const expectedPayload = {
+                    Event: SennheiserEvents.SystemInformation,
+                    EventType: SennheiserEventTypes.Request,
+                };
+                sennheiserService.isConnected = true;
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._sendMessage).toHaveBeenCalledTimes(1);
+                expect(sennheiserService._sendMessage).toHaveBeenCalledWith(expectedPayload);
+            });
+            it('should set isConnecting to false', () => {
+                sennheiserService.isConnecting = true;
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.isConnecting).toBe(false);
+            });
+            it('should set isConnected to true', () => {
+                sennheiserService.isConnected = false;
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.isConnected).toBe(true);
+            });
+        });
+        describe(`event type: ${SennheiserEvents.HeadsetConnected}`, () => {
+            it('should set deviceInfo to the correct values if payload.HeadsetName is defined', () => {
+                const name = 'Test Headset';
+                const type = 'The kind that you wear on your head';
+                message = {
+                    data: `{
+            "Event": "${SennheiserEvents.HeadsetConnected}",
+            "HeadsetName": "${name}",
+            "HeadsetType": "${type}"
+          }`,
+                };
+                sennheiserService.deviceInfo = null;
+                const expectedDeviceInfo = {
+                    deviceName: name,
+                    headsetType: type,
+                };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceInfo).toEqual(expectedDeviceInfo);
+            });
+            it('should not change deviceInfo if payload.HeadsetName is undefined', () => {
+                message = { data: `{ "Event": "${SennheiserEvents.HeadsetConnected}" }` };
+                const expectedDeviceInfo = {
+                    deviceName: 'Test Headset',
+                    headsetType: 'Test Headset Type',
+                };
+                sennheiserService.deviceInfo = expectedDeviceInfo;
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceInfo).toEqual(expectedDeviceInfo);
+            });
+        });
+        describe(`event type: ${SennheiserEvents.HeadsetDisconnected}`, () => {
+            it('should set deviceInfo to null if the HeadsetName on the payload is the same as the currently set deviceName', () => {
+                const testDeviceName = 'Test Device';
+                message = {
+                    data: `{
+            "Event": "${SennheiserEvents.HeadsetDisconnected}",
+            "HeadsetName": "${testDeviceName}"
+          }`,
+                };
+                sennheiserService.deviceInfo = { ProductName: testDeviceName };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceInfo).toBeNull();
+            });
+            it('should NOT set deviceInfo to null if the HeadsetName on the payload is the different than the currently set deviceName', () => {
+                const testDeviceName1 = 'Test Device 1';
+                const testDeviceName2 = 'Test Device 2';
+                message = {
+                    data: `{
+            "Event": "${SennheiserEvents.HeadsetDisconnected}",
+            "HeadsetName": "${testDeviceName2}"
+          }`,
+                };
+                sennheiserService.deviceInfo = { ProductName: testDeviceName1 };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceInfo).not.toBeNull();
+                expect(sennheiserService.deviceInfo.ProductName).toEqual(testDeviceName1);
+            });
+        });
+        describe(`event type: ${SennheiserEvents.IncomingCallAccepted}`, () => {
+            it(`should call deviceAnsweredCall() when the payload EventType is '${SennheiserEventTypes.Notification}'`, () => {
+                message = {
+                    data: `{
+            "Event": "${SennheiserEvents.IncomingCallAccepted}",
+            "EventType": "${SennheiserEventTypes.Notification}"
+          }`,
+                };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceAnsweredCall).toHaveBeenCalledTimes(1);
+            });
+            it(`should NOT call deviceAnsweredCall() when the payload EventType is NOT '${SennheiserEventTypes.Notification}'`, () => {
+                message = {
+                    data: `{
+            "Event": "${SennheiserEvents.IncomingCallAccepted}",
+            "EventType": "${SennheiserEventTypes.Ack}"
+          }`,
+                };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceAnsweredCall).not.toHaveBeenCalled();
+            });
+        });
+        describe(`event type: ${SennheiserEvents.Hold}`, () => {
+            it(`should call _handleAck with the payload if the event type is '${SennheiserEventTypes.Notification}'`, () => {
+                const expectedPayload = {
+                    Event: SennheiserEvents.Hold,
+                    EventType: SennheiserEventTypes.Ack,
+                };
+                message = { data: JSON.stringify(expectedPayload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._handleAck).toHaveBeenCalledWith(expectedPayload);
+                expect(sennheiserService.deviceHoldStatusChanged).not.toHaveBeenCalled();
+            });
+            it(`should call deviceHoldStatusChanged(true) if the event type is NOT ${SennheiserEventTypes.Notification}`, () => {
+                const expectedPayload = {
+                    CallID: '23f897b',
+                    Event: SennheiserEvents.Hold,
+                    EventType: SennheiserEventTypes.Notification,
+                };
+                message = { data: JSON.stringify(expectedPayload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._handleAck).not.toHaveBeenCalled();
+                expect(sennheiserService.deviceHoldStatusChanged).toHaveBeenCalledWith({ holdRequested: true, name: SennheiserEvents.Hold, conversationId: expectedPayload.CallID });
+            });
+        });
+        describe(`event type: ${SennheiserEvents.Resume}`, () => {
+            it(`should call _handleAck with the payload if the event type is '${SennheiserEventTypes.Ack}'`, () => {
+                const expectedPayload = {
+                    Event: SennheiserEvents.Resume,
+                    EventType: SennheiserEventTypes.Ack,
+                };
+                message = { data: JSON.stringify(expectedPayload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._handleAck).toHaveBeenCalledWith(expectedPayload);
+                expect(sennheiserService.deviceHoldStatusChanged).not.toHaveBeenCalled();
+            });
+            it(`should call deviceHoldStatusChanged(false) if the event type is NOT ${SennheiserEventTypes.Notification}`, () => {
+                const expectedPayload = {
+                    CallID: '23f897b',
+                    Event: SennheiserEvents.Resume,
+                    EventType: SennheiserEventTypes.Notification,
+                };
+                message = { data: JSON.stringify(expectedPayload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._handleAck).not.toHaveBeenCalled();
+                expect(sennheiserService.deviceHoldStatusChanged).toHaveBeenCalledWith({ holdRequested: false, name: SennheiserEvents.Resume, conversationId: expectedPayload.CallID });
+            });
+        });
+        describe(`event type: ${SennheiserEvents.MuteFromHeadset}`, () => {
+            it('should call deviceMuteChanged(true)', () => {
+                message = { data: `{ "Event": "${SennheiserEvents.MuteFromHeadset}" }` };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceMuteChanged).toHaveBeenCalledWith({ isMuted: true, name: SennheiserEvents.MuteFromHeadset });
+            });
+        });
+        describe(`event type: ${SennheiserEvents.UnmuteFromHeadset}`, () => {
+            it('should call deviceMuteChanged(false)', () => {
+                message = { data: `{ "Event": "${SennheiserEvents.UnmuteFromHeadset}" }` };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceMuteChanged).toHaveBeenCalledWith({ isMuted: false, name: SennheiserEvents.UnmuteFromHeadset });
+            });
+        });
+        describe(`event type: ${SennheiserEvents.CallEnded}`, () => {
+            it('should delete the call mappings for callId and conversationId', () => {
+                const payload = {
+                    CallID: '23f897b',
+                    Event: SennheiserEvents.CallEnded,
+                    EventType: SennheiserEventTypes.Notification,
+                };
+                message = { data: JSON.stringify(payload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceEndedCall).toHaveBeenCalledWith({ name: SennheiserEvents.CallEnded, conversationId: payload.CallID });
+            });
+            it(`should call deviceEndedCall() when the payload event type is '${SennheiserEventTypes.Notification}'`, () => {
+                const payload = {
+                    Event: SennheiserEvents.CallEnded,
+                    EventType: SennheiserEventTypes.Notification,
+                };
+                message = { data: JSON.stringify(payload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceEndedCall).toHaveBeenCalledTimes(1);
+            });
+            it(`should NOT call deviceEndedCall() when the payload event type is NOT '${SennheiserEventTypes.Notification}'`, () => {
+                const payload = {
+                    Event: SennheiserEvents.CallEnded,
+                    EventType: SennheiserEventTypes.Ack,
+                };
+                message = { data: JSON.stringify(payload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceEndedCall).not.toHaveBeenCalled();
+            });
+        });
+        describe(`event type: ${SennheiserEvents.IncomingCallRejected}`, () => {
+            it('should call deviceRejectedCall() with the relevant conversationID', () => {
+                const conversationId = '12r3kh';
+                const payload = {
+                    CallID: conversationId,
+                    Event: SennheiserEvents.IncomingCallRejected,
+                };
+                message = { data: JSON.stringify(payload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.deviceRejectedCall).toHaveBeenCalledWith({ name: payload.Event, conversationId: payload.CallID });
+            });
+        });
+        describe(`event type: ${SennheiserEvents.TerminateConnection}`, () => {
+            let mockWebSocket;
+            beforeEach(() => {
+                mockWebSocket = sennheiserService.websocket;
+            });
+            it('should close the websocket connection if the socket.ReadyState === 1, and set the websocket to null', () => {
+                message = { data: `{ "Event": "${SennheiserEvents.TerminateConnection}" }` };
+                mockWebSocket.readyState = 1;
+                jest.spyOn(mockWebSocket, 'close');
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.websocket).toBeNull();
+                expect(mockWebSocket.close).toHaveBeenCalled();
+            });
+            it('should NOT call close() on the websocket if socket.ReadyState is !== 1', () => {
+                message = { data: `{ "Event": "${SennheiserEvents.TerminateConnection}" }` };
+                mockWebSocket.readyState = 2;
+                jest.spyOn(mockWebSocket, 'close');
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService.websocket).toBeNull();
+                expect(mockWebSocket.close).not.toHaveBeenCalled();
+            });
+        });
+        describe('default case', () => {
+            it(`should call _handleAck with the given payload when the event type is ${SennheiserEventTypes.Ack}`, () => {
+                const payload = {
+                    Event: 'UnexpectedEvent',
+                    EventType: SennheiserEventTypes.Ack,
+                };
+                message = { data: JSON.stringify(payload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._handleAck).toHaveBeenCalledWith(payload);
+            });
+            it(`should call NOT _handleAck with the given payload when the event type is NOT ${SennheiserEventTypes.Ack}`, () => {
+                const payload = {
+                    Event: 'UnexpectedEvent',
+                    EventType: SennheiserEventTypes.Notification,
+                };
+                message = { data: JSON.stringify(payload) };
+                sennheiserService._handleMessage(message);
+                expect(sennheiserService._handleAck).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('endAllCalls', () => {
+        it('should return a Promise<void>', () => {
+            jest.spyOn(mockLogger, 'warn');
+            sennheiserService.endAllCalls();
+            expect(mockLogger.warn).toHaveBeenCalled();
+        });
+    });
+    describe('webSocketOnOpen', () => {
+        it('should set websocketConnected to true', () => {
+            sennheiserService.websocketConnected = false;
+            sennheiserService.webSocketOnOpen();
+            expect(sennheiserService.websocketConnected).toBe(true);
+        });
+        it('should call logger to inform that the websocket is connected', () => {
+            jest.spyOn(mockLogger, 'info');
+            sennheiserService.webSocketOnOpen();
+            expect(mockLogger.info).toHaveBeenCalled();
+        });
+    });
+    describe('webSocketOnClose', () => {
+        beforeEach(() => {
+            sennheiserService.websocketConnected = true;
+        });
+        it('should set websocketConnected to false', () => {
+            sennheiserService.webSocketOnClose({ code: 123, reason: 'something broke', wasClean: true });
+            expect(sennheiserService.websocketConnected).toBe(false);
+        });
+        it('should log error for unclean close', () => {
+            const spy = sennheiserService.logger.error = jest.fn();
+            const err = { code: 123, reason: 'something broke', wasClean: false };
+            sennheiserService.webSocketOnClose(err);
+            expect(sennheiserService.websocketConnected).toBe(false);
+            expect(spy).toHaveBeenCalledWith(err);
+        });
+        it('should log an error message when err.wasClean is false', () => {
+            jest.spyOn(mockLogger, 'error');
+            const err = { code: 123, reason: 'something broke', wasClean: true };
+            sennheiserService.webSocketOnClose(err);
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+        it('should set isConnecting to false', () => {
+            sennheiserService.isConnecting = true;
+            sennheiserService.webSocketOnClose({ code: 123, reason: 'something broke', wasClean: true });
+            expect(sennheiserService.isConnecting).toBe(false);
+        });
+        it('should set isConnected to false', () => {
+            sennheiserService.isConnected = true;
+            sennheiserService.webSocketOnClose({ code: 123, reason: 'something broke', wasClean: true });
+            expect(sennheiserService.isConnected).toBe(false);
+        });
+        it('should log an error if isConnected is false', () => {
+            sennheiserService.isConnected = false;
+            jest.spyOn(mockLogger, 'error');
+            sennheiserService.webSocketOnClose({ code: 123, reason: 'something broke', wasClean: true });
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+        it("should set errorCode to 'browser' when isConnected is false and the browser is Firefox", () => {
+            sennheiserService.isConnected = false;
+            sennheiserService.errorCode = null;
+            jest.spyOn(utils, 'isFirefox').mockReturnValue(true);
+            sennheiserService.webSocketOnClose({ code: 123, reason: 'something broke', wasClean: true });
+            expect(sennheiserService.errorCode).toEqual('browser');
+        });
+        it('should set disableRetry to true when isConnected is false and the browser is Firefox', () => {
+            sennheiserService.isConnected = false;
+            sennheiserService.disableRetry = false;
+            jest.spyOn(utils, 'isFirefox').mockReturnValue(true);
+            sennheiserService.webSocketOnClose({ code: 123, reason: 'something broke', wasClean: true });
+            expect(sennheiserService.disableRetry).toEqual(true);
+        });
+    });
+    describe('connect', () => {
+        it('should set isConnecting to true and isConnected to false', () => {
+            sennheiserService.isConnecting = false;
+            sennheiserService.isConnected = true;
+            sennheiserService.connect();
+            expect(sennheiserService.isConnected).toBe(false);
+            expect(sennheiserService.isConnecting).toBe(true);
+        });
+        it('should set the socket opopen, onclose, and onmessage functions', () => {
+            sennheiserService.websocket = null;
+            sennheiserService.connect();
+            expect(typeof sennheiserService.websocket.onopen).toBe('function');
+            expect(typeof sennheiserService.websocket.onclose).toBe('function');
+            expect(typeof sennheiserService.websocket.onmessage).toBe('function');
+        });
+        it('should set the service websocket', () => {
+            sennheiserService.websocket = null;
+            sennheiserService.connect();
+            expect(sennheiserService.websocket).toBeTruthy();
+        });
+    });
+});
+//# sourceMappingURL=sennheiser.test.js.map