softphone-vendor-headsets 1.0.1 → 2.0.0-develop.11

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

@@ -21,6 +21,7 @@ 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");
+const rxjs_1 = require("rxjs");
 jest.mock('broadcast-channel');
 describe('HeadsetService', () => {
     let plantronics;
@@ -29,10 +30,8 @@ describe('HeadsetService', () => {
     let jabraNative;
     let jabra;
     let headsetService;
-    // let jabraSdk: Promise<IApi>;
     const config = { logger: console };
     beforeEach(() => {
-        // jabraSdk = initializeSdk(subject);
         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' }));
@@ -180,35 +179,123 @@ describe('HeadsetService', () => {
         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 = '1234';
+            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('shouldnot call answerCall on the selected implmenetation when the implementation is not connected', () => {
+        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('answerCall', () => {
+    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 = '1234';
+            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('shouldnot call answerCall on the selected implmenetation when the implementation is not connected', () => {
+        it('should not call rejectCall on the selected implmenetation when the implementation is not connected', () => {
             const conversationId = '1234';
             plantronics.isConnected = false;
             headsetService.rejectCall(conversationId);
@@ -224,10 +311,35 @@ describe('HeadsetService', () => {
         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;
@@ -244,9 +356,33 @@ describe('HeadsetService', () => {
         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 = '1234';
+            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);
         });
@@ -259,19 +395,86 @@ describe('HeadsetService', () => {
     });
     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 = '1234';
+            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';
@@ -283,17 +486,97 @@ describe('HeadsetService', () => {
     });
     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;
@@ -311,11 +594,20 @@ describe('HeadsetService', () => {
             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: {} } });
+            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: {} } };
+            const testEvent = { vendor: plantronics, body: { name: 'AcceptCall', code: '1', conversationId: 'convoId123', event: {} } };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: true,
+                    conversationId: testEvent.body.conversationId
+                }
+            };
             headsetService.headsetEvents$.subscribe((event) => {
                 expect(event.event).toBe('deviceAnsweredCall');
                 expect(event.payload).toStrictEqual(testEvent.body);
@@ -323,43 +615,128 @@ describe('HeadsetService', () => {
             });
             headsetService.selectedImplementation = plantronics;
             headsetService['handleDeviceAnsweredCall'](testEvent);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toStrictEqual({
+                offHook: true,
+                muted: false,
+                held: false,
+                ringing: false,
+                conversationId: testEvent.body.conversationId
+            });
         });
     });
     describe('triggerDeviceRejectedCall', () => {
         beforeEach(() => {
+            jest.useFakeTimers();
             headsetService = headset_1.default.getInstance(config);
         });
+        afterEach(() => {
+            jest.useRealTimers();
+        });
         it('should return nothing if the selected implementation does not match the vendor passed in from the event', () => {
-            const result = headsetService['handleDeviceRejectedCall']({ vendor: {}, body: { conversationId: 'a1b2c3' } });
+            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' });
+                expect(event.payload).toStrictEqual({ conversationId: 'a1b2c3', name: 'callrejected' });
                 done();
             });
             headsetService.selectedImplementation = plantronics;
-            const testEvent = { vendor: plantronics, body: { conversationId: 'a1b2c3' } };
+            const testEvent = { vendor: plantronics, body: { name: 'callrejected', conversationId: 'a1b2c3' } };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: true,
+                    conversationId: testEvent.body.conversationId
+                }
+            };
+            headsetService['handleDeviceRejectedCall'](testEvent);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toMatchObject({
+                offHook: false,
+                muted: false,
+                held: false,
+                ringing: false,
+                conversationId: testEvent.body.conversationId
+            });
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toHaveProperty('removeTimer');
+            jest.advanceTimersByTime(3100);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toBeFalsy();
+        });
+        it('should do nothing if already in expected state', () => {
+            headsetService.selectedImplementation = plantronics;
+            const testEvent = { vendor: plantronics, body: { name: 'callrejected', conversationId: 'a1b2c3' } };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: {
+                    offHook: false,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: testEvent.body.conversationId
+                }
+            };
+            const timeoutSpy = jest.spyOn(window, 'setTimeout');
             headsetService['handleDeviceRejectedCall'](testEvent);
+            expect(timeoutSpy).not.toHaveBeenCalled();
+            timeoutSpy.mockRestore();
         });
     });
     describe('triggerDeviceEndedCall', () => {
         beforeEach(() => {
+            jest.useFakeTimers();
             headsetService = headset_1.default.getInstance(config);
+            jest.resetAllMocks();
+        });
+        afterEach(() => {
+            jest.useRealTimers();
         });
         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: {} } };
+            const testEvent = { vendor: {}, body: { name: 'TerminateCall', code: '2', event: {}, conversationId: 'convo421' } };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: testEvent.body.conversationId
+                }
+            };
+            headsetService['handleDeviceEndedCall'](testEvent);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toMatchObject({
+                offHook: false,
+                muted: false,
+                held: false,
+                ringing: false,
+                conversationId: testEvent.body.conversationId
+            });
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toHaveProperty('removeTimer');
+            jest.advanceTimersByTime(3100);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toBeFalsy();
+        });
+        it('should do nothing if already in expected state', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testEvent = { vendor: {}, body: { name: 'TerminateCall', code: '2', event: {}, conversationId: 'convo421' } };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: {
+                    conversationId: testEvent.body.conversationId,
+                    held: false,
+                    muted: false,
+                    offHook: false,
+                    ringing: false,
+                    removeTimer: 12525
+                }
+            };
+            const timeoutSpy = jest.spyOn(window, 'setTimeout');
             headsetService['handleDeviceEndedCall'](testEvent);
-        });
+            expect(timeoutSpy).not.toHaveBeenCalled();
+            timeoutSpy.mockRestore();
+        }));
     });
     describe('triggerDeviceMuteStatusChanged', () => {
         beforeEach(() => {
@@ -371,8 +748,39 @@ describe('HeadsetService', () => {
                 expect(event.payload).toStrictEqual(testEvent.body);
                 done();
             });
-            const testEvent = { vendor: {}, body: { name: 'Unmute', code: '12', event: {}, isMuted: false } };
+            const testEvent = { vendor: {}, body: { name: 'Mute', code: '12', event: {}, isMuted: true, conversationId: 'crazy88' } };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: testEvent.body.conversationId
+                }
+            };
             headsetService['handleDeviceMuteStatusChanged'](testEvent);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toStrictEqual({
+                offHook: true,
+                muted: true,
+                held: false,
+                ringing: false,
+                conversationId: testEvent.body.conversationId
+            });
+        });
+        it('should do nothing if already in expected state', () => {
+            const testEvent = { vendor: {}, body: { name: 'Mute', code: '12', event: {}, isMuted: true, conversationId: 'crazy88' } };
+            const testObject = {
+                offHook: true,
+                muted: true,
+                held: false,
+                ringing: false,
+                conversationId: testEvent.body.conversationId
+            };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: testObject
+            };
+            headsetService['handleDeviceMuteStatusChanged'](testEvent);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toStrictEqual(testObject);
         });
     });
     describe('triggerDeviceHoldStatusChanged', () => {
@@ -385,8 +793,24 @@ describe('HeadsetService', () => {
                 expect(event.payload).toStrictEqual(testEvent.body);
                 done();
             });
-            const testEvent = { vendor: {}, body: { name: 'HoldCall', code: '3', event: {}, holdRequested: true, toggle: false } };
+            const testEvent = { vendor: {}, body: { name: 'HoldCall', code: '3', event: {}, holdRequested: true, toggle: false, conversationId: 'convo41556' } };
+            headsetService['headsetConversationStates'] = {
+                [testEvent.body.conversationId]: {
+                    offHook: true,
+                    muted: false,
+                    held: false,
+                    ringing: false,
+                    conversationId: testEvent.body.conversationId
+                }
+            };
             headsetService['handleDeviceHoldStatusChanged'](testEvent);
+            expect(headsetService['headsetConversationStates'][testEvent.body.conversationId]).toStrictEqual({
+                offHook: true,
+                muted: false,
+                held: true,
+                ringing: false,
+                conversationId: testEvent.body.conversationId
+            });
         });
     });
     describe('handleWebHidPermissionRequested', () => {
@@ -451,6 +875,34 @@ describe('HeadsetService', () => {
             headsetService.activeMicChange('test test');
             expect(disconnectSpy).toHaveBeenCalled();
         }));
+        it('should not clear if there is no active vendor', () => {
+            const spy = headsetService['clearSelectedImplementation'] = jest.fn();
+            headsetService.selectedImplementation = null;
+            // should not find a selectable vendor
+            headsetService.activeMicChange('bose');
+            expect(spy).not.toHaveBeenCalled();
+        });
+        it('should clear if no new vendor', () => {
+            const spy = headsetService['clearSelectedImplementation'] = jest.fn();
+            headsetService.selectedImplementation = {};
+            // should not find a selectable vendor
+            headsetService.activeMicChange('bose');
+            expect(spy).toHaveBeenCalled();
+        });
+    });
+    describe('clearSelectedImplementation', () => {
+        it('should only emit an event if there is a selected implementation', () => {
+            headsetService.selectedImplementation = null;
+            const spy = jest.fn();
+            headsetService.headsetEvents$
+                .pipe((0, rxjs_1.filter)((event) => event.event === consumed_headset_events_1.HeadsetEvents.implementationChanged)).subscribe(spy);
+            headsetService['clearSelectedImplementation']();
+            expect(spy).not.toHaveBeenCalled();
+            headsetService.selectedImplementation = { disconnect: jest.fn() };
+            headsetService['clearSelectedImplementation']();
+            expect(spy).toHaveBeenCalled();
+            expect(headsetService.selectedImplementation).toBeNull();
+        });
     });
     describe('retryConnection', () => {
         beforeEach(() => {
@@ -483,5 +935,35 @@ describe('HeadsetService', () => {
             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