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

package/dist/cjs/src/library/services/headset.test.js

@@ -0,0 +1,800 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const headset_1 = __importDefault(require("./headset"));
+const vendor_implementation_1 = require("./vendor-implementations/vendor-implementation");
+const plantronics_1 = __importDefault(require("./vendor-implementations/plantronics/plantronics"));
+const sennheiser_1 = __importDefault(require("./vendor-implementations/sennheiser/sennheiser"));
+const jabra_native_1 = __importDefault(require("./vendor-implementations/jabra/jabra-native/jabra-native"));
+const jabra_1 = __importDefault(require("./vendor-implementations/jabra/jabra"));
+require("regenerator-runtime");
+const broadcast_channel_1 = require("broadcast-channel");
+const consumed_headset_events_1 = require("../types/consumed-headset-events");
+jest.mock('broadcast-channel');
+describe('HeadsetService', () => {
+    let plantronics;
+    let sennheiser;
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    let jabraNative;
+    let jabra;
+    let headsetService;
+    const config = { logger: console };
+    beforeEach(() => {
+        headsetService = headset_1.default.getInstance(Object.assign(Object.assign({}, config), { createNew: true }));
+        plantronics = plantronics_1.default.getInstance(Object.assign(Object.assign({}, config), { vendorName: 'Plantronics' }));
+        sennheiser = sennheiser_1.default.getInstance(Object.assign(Object.assign({}, config), { vendorName: 'Sennheiser' }));
+        jabraNative = jabra_native_1.default.getInstance(Object.assign(Object.assign({}, config), { vendorName: 'JabraNative' }));
+        /* eslint-enable */
+        jabra = jabra_1.default.getInstance(Object.assign(Object.assign({}, config), { vendorName: 'Jabra' }));
+        jest.spyOn(sennheiser, 'connect').mockResolvedValue(true);
+        jest.spyOn(plantronics, 'connect').mockResolvedValue(true);
+        jest.spyOn(sennheiser, 'disconnect').mockResolvedValue(true);
+        jest.spyOn(plantronics, 'disconnect').mockResolvedValue(true);
+    });
+    afterEach(() => {
+        headsetService = null;
+        plantronics = null;
+        sennheiser = null;
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        jabraNative = null;
+        /* eslint-enable */
+        jabra = null;
+        jest.resetAllMocks();
+        jest.resetModules();
+    });
+    describe('instantiation', () => {
+        it('should be a singleton', () => {
+            headsetService = headset_1.default.getInstance(config);
+            const headsetService2 = headset_1.default.getInstance(config);
+            expect(headsetService).not.toBeFalsy();
+            expect(headsetService2).not.toBeFalsy();
+            expect(headsetService).toBe(headsetService2);
+        });
+        it('should fallback to console logger', () => {
+            headsetService = headset_1.default.getInstance({ createNew: true, logger: null });
+            expect(headsetService['logger']).toBe(console);
+        });
+    });
+    describe('implementations', () => {
+        it('should only include implementations that are supported', () => {
+            headsetService = headset_1.default.getInstance(config);
+            [headsetService['plantronics'], headsetService['sennheiser'], headsetService['jabra'], headsetService['jabraNative']]
+                .forEach((impl) => {
+                impl.isSupported = jest.fn().mockReturnValue(true);
+            });
+            headsetService['_implementations'] = [];
+            expect(headsetService.implementations.length).toBe(4);
+            [headsetService['jabra'], headsetService['jabraNative']].forEach((impl) => impl.isSupported.mockReturnValue(false));
+            headsetService['_implementations'] = [];
+            expect(headsetService.implementations.length).toBe(2);
+        });
+    });
+    describe('changeImplementation', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should do nothing if the implementation passed in is the current implementation', () => {
+            headsetService.selectedImplementation = sennheiser;
+            jest.spyOn(sennheiser, 'disconnect');
+            headsetService.changeImplementation(sennheiser, 'test label');
+            expect(sennheiser.disconnect).not.toHaveBeenCalled();
+        });
+        it('should change the selected implementation to what was passed in', () => __awaiter(void 0, void 0, void 0, function* () {
+            headsetService.selectedImplementation = sennheiser;
+            yield headsetService.changeImplementation(plantronics, 'test label');
+            expect(headsetService.selectedImplementation).toBe(plantronics);
+        }));
+        it('should call disconnect on the old implementation, and connect on the new implementation', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(sennheiser, 'disconnect');
+            jest.spyOn(plantronics, 'connect');
+            headsetService.selectedImplementation = sennheiser;
+            yield headsetService.changeImplementation(plantronics, 'test label');
+            expect(sennheiser.disconnect).toHaveBeenCalled();
+            expect(plantronics.connect).toHaveBeenCalled();
+        }));
+        it('should trigger implementationChanged event for new implementation', (done) => {
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe('implementationChanged');
+                expect(event.payload).toStrictEqual(plantronics);
+                expect(event.payload instanceof vendor_implementation_1.VendorImplementation).toBe(true);
+                done();
+            });
+            headsetService.selectedImplementation = sennheiser;
+            headsetService.changeImplementation(plantronics, 'test label');
+        });
+        it('should trigger implementationChanged event when clearing the implementation', done => {
+            headsetService.headsetEvents$.subscribe(value => {
+                expect(value.event).toBe('implementationChanged');
+                expect(value.payload).toBeNull();
+                done();
+            });
+            headsetService.selectedImplementation = plantronics;
+            headsetService.changeImplementation(null, '');
+        });
+    });
+    describe('incomingCall', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'incomingCall').mockResolvedValue({});
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.resetAllMocks();
+        });
+        it('should call incomingCall on the selected implementation when the implementation is connected', () => {
+            const callInfo = { conversationId: '1234', contactName: 'CM Punk' };
+            const hasOtherActiveCalls = false;
+            plantronics.isConnected = true;
+            headsetService.incomingCall(callInfo, hasOtherActiveCalls);
+            expect(plantronics.incomingCall).toHaveBeenCalledWith(callInfo, hasOtherActiveCalls);
+        });
+        it('shouldnot call incomingCall on the selected implmenetation when the implementation is not connected', () => {
+            const callInfo = { conversationId: '4321', contactName: 'Bryan Danielson' };
+            const hasOtherActiveCalls = false;
+            plantronics.isConnected = false;
+            headsetService.incomingCall(callInfo, hasOtherActiveCalls);
+            expect(plantronics.incomingCall).not.toHaveBeenCalled();
+        });
+    });
+    describe('outgoingCall', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'outgoingCall').mockResolvedValue({});
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.resetAllMocks();
+        });
+        it('should call outgoingCall on the selected implementation when the implementation is connected', () => {
+            const callInfo = { conversationId: '4567', contactName: 'Adam Cole' };
+            plantronics.isConnected = true;
+            headsetService.outgoingCall(callInfo);
+            expect(plantronics.outgoingCall).toHaveBeenCalledWith(callInfo);
+        });
+        it('shouldnot call outgoingCall on the selected implmenetation when the implementation is not connected', () => {
+            const callInfo = { conversationId: '7654', contactName: 'Marc Spector' };
+            plantronics.isConnected = false;
+            headsetService.outgoingCall(callInfo);
+            expect(plantronics.outgoingCall).not.toHaveBeenCalled();
+        });
+    });
+    describe('answerCall', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'answerCall').mockResolvedValue({});
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.resetAllMocks();
+        });
+        it('should do nothing if already in the expected state', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'convoId241123';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    offHook: true,
+                    muted: false,
+                    held: true,
+                    ringing: false,
+                    conversationId
+                }
+            };
+            yield headsetService.answerCall(conversationId);
+            expect(plantronics.answerCall).not.toHaveBeenCalled();
+        }));
+        it('should call answerCall on the selected implementation when the implementation is connected', () => {
+            const conversationId = 'convoId123';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                'convoId123': {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: true,
+                    conversationId: 'convoId123'
+                }
+            };
+            headsetService.answerCall(conversationId);
+            expect(plantronics.answerCall).toHaveBeenCalledWith(conversationId);
+        });
+        it('should not call answerCall on the selected implmenetation when the implementation is not connected', () => {
+            const conversationId = '1234';
+            plantronics.isConnected = false;
+            headsetService.answerCall(conversationId);
+            expect(plantronics.answerCall).not.toHaveBeenCalled();
+        });
+    });
+    describe('rejectCall', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'rejectCall').mockResolvedValue({});
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.resetAllMocks();
+            jest.useRealTimers();
+        });
+        it('should do nothing if already in expected state', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'convoId12523';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId
+                }
+            };
+            yield headsetService.rejectCall(conversationId);
+            expect(plantronics.rejectCall).not.toHaveBeenCalled();
+        }));
+        it('should not delete the headset state if there is no removeTimer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'convoId12523';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: true,
+                    conversationId
+                }
+            };
+            yield headsetService.rejectCall(conversationId);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeTruthy();
+            delete headsetService['headsetConversationStates'][conversationId].removeTimer;
+            jest.advanceTimersByTime(3000);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeTruthy();
+        }));
+        it('should delete the headset state if there is removeTimer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'convoId12523';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: true,
+                    conversationId
+                }
+            };
+            yield headsetService.rejectCall(conversationId);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeTruthy();
+            jest.advanceTimersByTime(3000);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeFalsy();
+        }));
+        it('should call rejectCall on the selected implementation when the implementation is connected', () => {
+            const conversationId = 'convoId123';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                'convoId123': {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: true,
+                    conversationId: 'convoId123'
+                }
+            };
+            headsetService.rejectCall(conversationId);
+            expect(plantronics.rejectCall).toHaveBeenCalledWith(conversationId);
+            expect(headsetService['headsetConversationStates']['convoId123'].removeTimer).toBeDefined();
+            jest.advanceTimersByTime(2500);
+            expect(headsetService['headsetConversationStates']).toStrictEqual({});
+        });
+        it('should not call rejectCall on the selected implmenetation when the implementation is not connected', () => {
+            const conversationId = '1234';
+            plantronics.isConnected = false;
+            headsetService.rejectCall(conversationId);
+            expect(plantronics.rejectCall).not.toHaveBeenCalled();
+        });
+    });
+    describe('setMute', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'setMute').mockResolvedValue({});
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.resetAllMocks();
+        });
+        it('should do nothing if all calls are muted', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'convoId123';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    offHook: true,
+                    muted: true,
+                    held: true,
+                    ringing: false,
+                    conversationId
+                }
+            };
+            yield headsetService.setMute(true);
+            expect(plantronics.setMute).not.toHaveBeenCalled();
+        }));
+        it('should call setMute on the selected implementation when the implementation is connected', () => {
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                'convoId123': {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: true,
+                    conversationId: 'convoId123'
+                }
+            };
+            headsetService.setMute(true);
+            expect(plantronics.setMute).toHaveBeenCalledWith(true);
+            expect(headsetService['headsetConversationStates']['convoId123'].muted).toBe(true);
+        });
+        it('shouldnot call setMute on the selected implmenetation when the implementation is not connected', () => {
+            plantronics.isConnected = false;
+            headsetService.setMute(true);
+            expect(plantronics.setMute).not.toHaveBeenCalled();
+        });
+    });
+    describe('setHold', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'setHold').mockResolvedValue(null);
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.resetAllMocks();
+        });
+        it('should do nothing if already in expected state', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'convoId123';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    offHook: true,
+                    muted: false,
+                    held: true,
+                    ringing: false,
+                    conversationId
+                }
+            };
+            yield headsetService.setHold(conversationId, true);
+            expect(plantronics.setHold).not.toHaveBeenCalled();
+        }));
+        it('should call setHold on the selected implementation when the implementation is connected', () => {
+            const conversationId = 'convoId123';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                'convoId123': {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: 'convoId123'
+                }
+            };
+            headsetService.setHold(conversationId, true);
+            expect(plantronics.setHold).toHaveBeenCalledWith(conversationId, true);
+        });
+        it('should not call setHold on the selected implmenetation when the implementation is not connected', () => {
+            const conversationId = '1234';
+            plantronics.isConnected = false;
+            headsetService.setHold(conversationId, true);
+            expect(plantronics.setHold).not.toHaveBeenCalled();
+        });
+    });
+    describe('endCall', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'endCall').mockResolvedValue({});
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+            jest.resetAllMocks();
+        });
+        it('should do nothing if already in expected state', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'myconvoId5';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    conversationId,
+                    held: false,
+                    muted: false,
+                    offHook: false,
+                    ringing: false,
+                    removeTimer: 12525
+                }
+            };
+            const timeoutSpy = jest.spyOn(window, 'setTimeout');
+            headsetService.endCall(conversationId, false);
+            expect(timeoutSpy).not.toHaveBeenCalled();
+            timeoutSpy.mockRestore();
+        }));
+        it('should delete headset state after time', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'myconvoId5';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    conversationId,
+                    held: false,
+                    muted: false,
+                    offHook: true,
+                    ringing: false,
+                }
+            };
+            yield headsetService.endCall(conversationId, false);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeTruthy();
+            jest.advanceTimersByTime(3000);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeFalsy();
+        }));
+        it('should not delete headset state after time if there is no removeTimer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conversationId = 'myconvoId5';
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    conversationId,
+                    held: false,
+                    muted: false,
+                    offHook: true,
+                    ringing: false,
+                }
+            };
+            yield headsetService.endCall(conversationId, false);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeTruthy();
+            delete headsetService['headsetConversationStates'][conversationId].removeTimer;
+            jest.advanceTimersByTime(3000);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeTruthy();
+        }));
+        it('should call endCall on the selected implementation when the implementation is connected', () => {
+            const conversationId = 'convoId123';
+            const hasOtherActiveCalls = false;
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                'convoId123': {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: 'convoId123'
+                }
+            };
+            headsetService.endCall(conversationId, hasOtherActiveCalls);
+            expect(plantronics.endCall).toHaveBeenCalledWith(conversationId, hasOtherActiveCalls);
+            expect(headsetService['headsetConversationStates']['convoId123'].removeTimer).toBeDefined();
+            jest.advanceTimersByTime(2500);
+            expect(headsetService['headsetConversationStates']).toStrictEqual({});
+        });
+        it('shouldnot call endCall on the selected implmenetation when the implementation is not connected', () => {
+            const conversationId = '1234';
+            const hasOtherActiveCalls = false;
+            plantronics.isConnected = false;
+            headsetService.endCall(conversationId, hasOtherActiveCalls);
+            expect(plantronics.endCall).not.toHaveBeenCalled();
+        });
+    });
+    describe('endAllCalls', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+            headsetService = headset_1.default.getInstance(config);
+            jest.spyOn(plantronics, 'endAllCalls').mockResolvedValue({});
+            headsetService.selectedImplementation = plantronics;
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+            jest.resetAllMocks();
+        });
+        it('should not setTimeout if there is already a remove timer', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                'myConvoId': {
+                    conversationId: 'myConvoId',
+                    held: false,
+                    muted: false,
+                    offHook: true,
+                    ringing: false,
+                    removeTimer: 12525
+                }
+            };
+            const timeoutSpy = jest.spyOn(window, 'setTimeout');
+            yield headsetService.endAllCalls();
+            expect(timeoutSpy).not.toHaveBeenCalled();
+            timeoutSpy.mockRestore();
+        }));
+        it('should not delete if theres no remove timer', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronics.isConnected = true;
+            const conversationId = 'myConvoId15521';
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    conversationId,
+                    held: false,
+                    muted: false,
+                    offHook: true,
+                    ringing: false,
+                }
+            };
+            yield headsetService.endAllCalls();
+            delete headsetService['headsetConversationStates'][conversationId].removeTimer;
+            jest.advanceTimersByTime(3000);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeTruthy();
+        }));
+        it('should delete headset state', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronics.isConnected = true;
+            const conversationId = 'myConvoId151';
+            headsetService['headsetConversationStates'] = {
+                [conversationId]: {
+                    conversationId,
+                    held: false,
+                    muted: false,
+                    offHook: true,
+                    ringing: false,
+                }
+            };
+            yield headsetService.endAllCalls();
+            jest.advanceTimersByTime(3000);
+            expect(headsetService['headsetConversationStates'][conversationId]).toBeFalsy();
+        }));
+        it('should call endAllCalls on the selected implementation when the implementation is connected', () => {
+            plantronics.isConnected = true;
+            headsetService['headsetConversationStates'] = {
+                'convoId123': {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: 'convoId123'
+                },
+                'convoId456': {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: 'convoId456'
+                },
+                'convoId789': {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: 'convoId789'
+                }
+            };
+            headsetService.endAllCalls();
+            Object.keys(headsetService['headsetConversationStates']).forEach((key) => {
+                expect(headsetService['headsetConversationStates'][key].removeTimer).toBeDefined();
+            });
+            expect(plantronics.endAllCalls).toHaveBeenCalled();
+            jest.advanceTimersByTime(2500);
+            expect(headsetService['headsetConversationStates']).toStrictEqual({});
+        });
+        it('shouldnot call endAllCalls on the selected implmenetation when the implementation is not connected', () => {
+            plantronics.isConnected = false;
+            headsetService.endAllCalls();
+            expect(plantronics.endAllCalls).not.toHaveBeenCalled();
+        });
+    });
+    describe('triggerDeviceAnsweredCall', () => {
+        Object.defineProperty(window.navigator, 'hid', { get: () => ({
+                getDevices: () => { return []; }
+            }) });
+        Object.defineProperty(window.navigator, 'locks', { get: () => ({}) });
+        window.BroadcastChannel = broadcast_channel_1.BroadcastChannel;
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should return nothing if the selected implementation does not match the vendor passed in from the event', () => {
+            const result = headsetService['handleDeviceAnsweredCall']({ vendor: {}, body: { name: 'AcceptCall', code: '1', event: {}, conversationId: 'myconvo' } });
+            expect(result).toBeUndefined();
+        });
+        it('should send a headset event of type DEVICE_ANSWERED_CALL', (done) => {
+            const testEvent = { vendor: plantronics, body: { name: 'AcceptCall', code: '1', event: {} } };
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe('deviceAnsweredCall');
+                expect(event.payload).toStrictEqual(testEvent.body);
+                done();
+            });
+            headsetService.selectedImplementation = plantronics;
+            headsetService['handleDeviceAnsweredCall'](testEvent);
+        });
+    });
+    describe('triggerDeviceRejectedCall', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should return nothing if the selected implementation does not match the vendor passed in from the event', () => {
+            const result = headsetService['handleDeviceRejectedCall']({ vendor: {}, body: { name: 'CallRejected', conversationId: 'a1b2c3' } });
+            expect(result).toBeUndefined();
+        });
+        it('should send a headset event of type DEVICE_REJECTED_CALL', (done) => {
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe('deviceRejectedCall');
+                expect(event.payload).toStrictEqual({ conversationId: 'a1b2c3', name: 'callrejected' });
+                done();
+            });
+            headsetService.selectedImplementation = plantronics;
+            const testEvent = { vendor: plantronics, body: { name: 'callrejected', conversationId: 'a1b2c3' } };
+            headsetService['handleDeviceRejectedCall'](testEvent);
+        });
+    });
+    describe('triggerDeviceEndedCall', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+            jest.resetAllMocks();
+        });
+        it('should send a headset event of type DEVICE_ENDED_CALL', (done) => {
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe('deviceEndedCall');
+                expect(event.payload).toStrictEqual(testEvent.body);
+                done();
+                expect(event.event).toBe('loggableEvent');
+                expect(event.payload).toStrictEqual(testEvent.body);
+                done();
+            });
+            const testEvent = { vendor: {}, body: { name: 'TerminateCall', code: '2', event: {}, conversationId: 'convo421' } };
+            headsetService['handleDeviceEndedCall'](testEvent);
+        });
+    });
+    describe('triggerDeviceMuteStatusChanged', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should send a headset event of type DEVICE_MUTE_STATUS_CHANGED', (done) => {
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe('deviceMuteStatusChanged');
+                expect(event.payload).toStrictEqual(testEvent.body);
+                done();
+            });
+            const testEvent = { vendor: {}, body: { name: 'Unmute', code: '12', event: {}, isMuted: false } };
+            headsetService['handleDeviceMuteStatusChanged'](testEvent);
+        });
+    });
+    describe('triggerDeviceHoldStatusChanged', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should send a headset event of type DEVICE_HOLD_STATUS_CHANGED', (done) => {
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe('deviceHoldStatusChanged');
+                expect(event.payload).toStrictEqual(testEvent.body);
+                done();
+            });
+            const testEvent = { vendor: {}, body: { name: 'HoldCall', code: '3', event: {}, holdRequested: true, toggle: false, conversationId: 'convo41556' } };
+            headsetService['handleDeviceHoldStatusChanged'](testEvent);
+        });
+    });
+    describe('handleWebHidPermissionRequested', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should send a headset event of type webHidPermissionRequested', (done) => {
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe(consumed_headset_events_1.HeadsetEvents.webHidPermissionRequested);
+                expect(event.payload).toStrictEqual(testEvent.body);
+                done();
+            });
+            const testEvent = {
+                vendor: {},
+                body: {
+                    callback: () => { return; }
+                }
+            };
+            headsetService['handleWebHidPermissionRequested'](testEvent);
+        });
+    });
+    describe('triggerDeviceLogs', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should send the "loggableEvent" event to the observable', (done) => {
+            headsetService.headsetEvents$.subscribe((event) => {
+                expect(event.event).toBe('loggableEvent');
+                expect(event.payload).toStrictEqual(testEvent.body);
+                done();
+            });
+            const testEvent = { vendor: plantronics, body: { name: 'CallRinging', code: 7, event: {} } };
+            headsetService['handleDeviceLogs'](testEvent);
+        });
+    });
+    describe('external mic change', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should check a values label to determine which microphone is selected', () => __awaiter(void 0, void 0, void 0, function* () {
+            const changeImplementationSpy = jest.spyOn(headsetService, 'changeImplementation');
+            const disconnectSpy = jest.spyOn(sennheiser, 'disconnect');
+            headsetService['jabra'].isSupported = jest.fn().mockReturnValue(true);
+            headsetService['plantronics'].isSupported = jest.fn().mockReturnValue(true);
+            headsetService['sennheiser'].isSupported = jest.fn().mockReturnValue(true);
+            headsetService.activeMicChange('jabra');
+            expect(changeImplementationSpy).toHaveBeenCalledWith(jabra, 'jabra');
+            headsetService.activeMicChange('plantronics test');
+            expect(changeImplementationSpy).toHaveBeenCalledWith(plantronics, 'plantronics test');
+            headsetService.activeMicChange('plt test');
+            expect(changeImplementationSpy).toHaveBeenCalledWith(plantronics, 'plt test');
+            headsetService.activeMicChange('sennheiser test');
+            expect(changeImplementationSpy).toHaveBeenCalledWith(sennheiser, 'sennheiser test');
+            headsetService.activeMicChange('senn test');
+            expect(changeImplementationSpy).toHaveBeenCalledWith(sennheiser, 'senn test');
+            yield headsetService.activeMicChange('epos test');
+            expect(changeImplementationSpy).toHaveBeenCalledWith(sennheiser, 'epos test');
+            headsetService.selectedImplementation = sennheiser;
+            headsetService.activeMicChange(undefined);
+            expect(headsetService.selectedImplementation).toBeNull();
+            expect(disconnectSpy).toHaveBeenCalled();
+            headsetService.activeMicChange('test test');
+            expect(disconnectSpy).toHaveBeenCalled();
+        }));
+    });
+    describe('retryConnection', () => {
+        beforeEach(() => {
+            headsetService = headset_1.default.getInstance(config);
+        });
+        it('should reject if not connected', () => __awaiter(void 0, void 0, void 0, function* () {
+            headsetService.selectedImplementation = null;
+            yield expect(() => headsetService.retryConnection('Test Label')).rejects.toThrow('No active headset');
+        }));
+        it('should call connect', () => __awaiter(void 0, void 0, void 0, function* () {
+            const impl = {
+                connect: jest.fn().mockResolvedValue(null)
+            };
+            headsetService.selectedImplementation = impl;
+            yield headsetService.retryConnection('Test Label');
+            expect(impl.connect).toHaveBeenCalledWith('Test Label');
+        }));
+    });
+    describe('connectionStatus', () => {
+        it('should return proper connection status', () => {
+            headsetService.selectedImplementation = plantronics;
+            headsetService.selectedImplementation.isConnected = true;
+            expect(headsetService.connectionStatus()).toBe('running');
+            headsetService.selectedImplementation.isConnecting = true;
+            headsetService.selectedImplementation.isConnected = false;
+            expect(headsetService.connectionStatus()).toBe('checking');
+            headsetService.selectedImplementation.isConnecting = false;
+            expect(headsetService.connectionStatus()).toBe('notRunning');
+            headsetService.selectedImplementation = null;
+            expect(headsetService.connectionStatus()).toBe('noVendor');
+        });
+    });
+    describe('isDifferentState', () => {
+        it('should return the negated value of state after finding a value in this.headsetConversationStates', () => {
+            headsetService['headsetConversationStates'] = {
+                'convoId123': {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: 'convoId123'
+                }
+            };
+            expect(headsetService['isDifferentState']({ conversationId: 'convoId123', state: {} })).toBe(false);
+        });
+        it('should check the passed in state if no state is pulled from this.headsetConversationStates', () => {
+            const testState = {
+                offHook: true,
+                muted: false,
+                held: false,
+                ringing: false,
+                conversationId: 'convoId123'
+            };
+            expect(headsetService['isDifferentState']({ conversationId: '828256', state: testState })).toStrictEqual(true);
+        });
+    });
+    describe('updateHeadsetState', () => {
+        it('should return false if the isDifferentState returns false, meaning the states are the same', () => {
+            headsetService['isDifferentState'] = jest.fn().mockReturnValueOnce(false);
+            expect(headsetService['updateHeadsetState']({ conversationId: 'convoId123', state: {} })).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=headset.test.js.map