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

package/dist/cjs/src/library/services/vendor-implementations/jabra/jabra.test.js

@@ -17,112 +17,65 @@ const rxjs_1 = require("rxjs");
 const jabra_js_1 = require("@gnaudio/jabra-js");
 const broadcast_channel_1 = require("broadcast-channel");
 require("regenerator-runtime");
-const test_utils_test_1 = require("../../../test-utils.test");
+const mock_jabra_sdk_1 = require("./mock-jabra-sdk");
 jest.mock('broadcast-channel');
-const testDevice1 = {
-    deviceName: 'Test Device 1',
-    ProductName: 'Super Headset',
-    headsetType: 'Wireless',
-};
-const testDevice2 = {
-    deviceName: 'Test Device 2',
-    ProductName: 'Yellow Headset',
-    headsetType: 'Wired with buttons',
-};
-const testDevice3 = {
-    deviceName: 'Test Device 3',
-    ProductName: 'Bluetooth Bannana',
-    headsetType: 'Looks like a fruit',
-};
 const flushPromises = () => Promise.resolve();
-function populateDevices(service) {
-    service.devices.set(testDevice1.deviceName, testDevice1);
-    service.devices.set(testDevice2.deviceName, testDevice2);
-    service.devices.set(testDevice3.deviceName, testDevice3);
-}
+const exceptionWithType = (message, type) => {
+    const error = new Error();
+    error.message = message;
+    error.type = type;
+    return error;
+};
 const createMockCallControl = (deviceSignalsObservable) => {
     return {
         device: jest.fn(),
         onDisconnect: jest.fn(),
         deviceSignals: deviceSignalsObservable,
-        takeCallLock: jest.fn(),
+        takeCallLock: jest.fn().mockResolvedValue(null),
         releaseCallLock: jest.fn(),
         offHook: jest.fn(),
         ring: jest.fn(),
         mute: jest.fn(),
-        hold: jest.fn()
+        hold: jest.fn(),
     };
 };
-const exceptionWithType = (message, type) => {
-    const error = new Error();
-    error.message = message;
-    error.type = type;
-    return error;
+const mockDevice1 = {
+    id: 123,
+    name: 'Test Label 123',
+    vendorId: 2830,
+    productId: 3648,
+    serialNumber: '123456789'
+};
+const mockDevice2 = {
+    id: 456,
+    name: 'Test Label 456',
+    vendorId: 2831,
+    productId: 3649,
+    serialNumber: '1234567891'
 };
 const initializeSdk = (subject) => __awaiter(void 0, void 0, void 0, function* () {
-    const sdk = yield jabra_js_1.init({
-        appId: 'softphone-vendor-headsets-test',
-        appName: 'Softphone Headset Library Test',
-        transport: jabra_js_1.RequestedBrowserTransport.CHROME_EXTENSION_WITH_WEB_HID_FALLBACK
-    });
-    const deviceList = [
-        {
-            id: 123,
-            name: 'Test Label 123',
-            vendorId: 2830,
-            productId: 3648,
-            serialNumber: '123456789',
-            currentConnections: [{
-                    hidChannel: {
-                        descriptor: [{
-                                reportSize: 1,
-                                reportType: 1,
-                                usage: 23,
-                                usagePage: 65344,
-                                valueType: "absolute"
-                            }],
-                    },
-                    type: 2
-                }],
-            type: 255,
-            browserLabel: 'Test Label 123:3648',
-        },
-        {
-            name: 'Definitely not this'
-        }
-    ];
-    sdk.deviceList = subject.asObservable();
-    subject.next(deviceList);
-    return sdk;
+    if (!subject) {
+        const deviceList = [
+            mockDevice1
+        ];
+        subject = new rxjs_1.BehaviorSubject(deviceList);
+    }
+    return new mock_jabra_sdk_1.MockJabraSdk(subject);
 });
-const resetJabraService = (service) => {
-    service.isConnecting = false;
-    service.isConnected = false;
-    service.isActive = false;
-    service.devices = new Map();
-    service.activeDeviceId = null;
-    service.logger = test_utils_test_1.mockLogger;
-    service._connectDeferred = null;
-};
 describe('JabraService', () => {
     let jabraService;
-    let jabraSdk;
-    const subject = new rxjs_1.ReplaySubject(1);
-    // const deviceSignalsSubject = new Subject<ICallControlSignal>();
-    // const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
-    Object.defineProperty(window.navigator, 'hid', { get: () => ({
-            getDevices: () => { return []; }
-        }) });
+    Object.defineProperty(window.navigator, 'hid', {
+        get: () => ({
+            getDevices: () => {
+                return [];
+            },
+        }),
+    });
     Object.defineProperty(window.navigator, 'locks', { get: () => ({}) });
     window.BroadcastChannel = broadcast_channel_1.BroadcastChannel;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        jabraSdk = initializeSdk(subject);
+    beforeEach(() => {
         jabraService = jabra_1.default.getInstance({ logger: console, createNew: true });
-        resetJabraService(jabraService);
-    }));
-    afterEach(() => {
-        jest.resetAllMocks();
-        jest.restoreAllMocks();
+        jabraService.initializeJabraSdk = initializeSdk;
     });
     describe('instantiation', () => {
         it('should be a singleton', () => {
@@ -152,121 +105,91 @@ describe('JabraService', () => {
         });
     });
     describe('initial connection', () => {
-        beforeEach(() => {
-            resetJabraService(jabraService);
-            jest.useFakeTimers();
-        });
-        afterEach(() => {
-            jest.clearAllTimers();
-            jest.useRealTimers();
-        });
-        it('should set the proper values while trying to connect; successfuly connect', () => __awaiter(void 0, void 0, void 0, function* () {
-            const processEventsSpy = jest.spyOn(jabraService, '_processEvents');
+        it('should use existing jabraSdk and connect', () => __awaiter(void 0, void 0, void 0, function* () {
+            jabraService.jabraSdk = (yield initializeSdk());
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
-            const callControlFactorySpy = jest.spyOn(jabraService, 'createCallControlFactory').mockReturnValue({
+            jabraService.callControlFactory = {
                 createCallControl: () => __awaiter(void 0, void 0, void 0, function* () {
                     return callControl;
                 })
-            });
+            };
             const testLabel = 'test label 123';
-            jabraService.jabraSdk = jabraSdk;
+            const initSdkSpy = jabraService['initializeJabraSdk'] = jest.fn();
             yield jabraService.connect(testLabel);
-            jest.runAllTimers();
-            yield flushPromises();
-            yield flushPromises();
-            yield flushPromises();
-            expect(callControlFactorySpy).toHaveBeenCalled();
-            expect(processEventsSpy).toHaveBeenCalledWith(callControl);
+            expect(initSdkSpy).not.toHaveBeenCalled();
             expect(jabraService.isConnected).toBe(true);
             expect(jabraService.isConnecting).toBe(false);
         }));
-        it('should set the proper values while trying to connect; failed to connect', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should init jabra sdk and connect', () => __awaiter(void 0, void 0, void 0, function* () {
+            const processEventsSpy = jest.spyOn(jabraService, '_processEvents');
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
-            jest.spyOn(jabraService, 'createCallControlFactory').mockReturnValue({
+            const callControlFactorySpy = jest
+                .spyOn(jabraService, 'createCallControlFactory')
+                .mockReturnValue({
                 createCallControl: () => __awaiter(void 0, void 0, void 0, function* () {
                     return callControl;
-                })
+                }),
             });
-            const deviceConnectionStatusChangedSpy = jest.spyOn(jabraService, 'changeConnectionStatus');
-            const errorLoggerSpy = jest.spyOn(jabraService.logger, 'error');
-            const requestWebHidPermissionsSpy = jest.spyOn(jabraService, 'requestWebHidPermissions');
-            const testLabel = 'test label 456';
-            jabraService.jabraSdk = jabraSdk;
+            const testLabel = 'test label 123';
             yield jabraService.connect(testLabel);
-            jest.runAllTimers();
-            yield flushPromises();
-            jest.runOnlyPendingTimers();
-            yield flushPromises();
-            yield flushPromises();
-            expect(requestWebHidPermissionsSpy).toHaveBeenCalled();
-            expect(deviceConnectionStatusChangedSpy).toHaveBeenCalled();
+            expect(callControlFactorySpy).toHaveBeenCalled();
+            expect(processEventsSpy).toHaveBeenCalledWith(callControl);
+            expect(jabraService.isConnected).toBe(true);
             expect(jabraService.isConnecting).toBe(false);
-            expect(errorLoggerSpy).toHaveBeenCalled();
-        }));
-        it('should set the proper values while trying to connect; failed initial connection, populated afterwards', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testDevices = [
-                {
-                    id: 123,
-                    name: 'Test Label 123',
-                    vendorId: 2830,
-                    productId: 3648,
-                    serialNumber: '123456789',
-                    currentConnections: [{
-                            hidChannel: {
-                                descriptor: [{
-                                        reportSize: 1,
-                                        reportType: 1,
-                                        usage: 23,
-                                        usagePage: 65344,
-                                        valueType: "absolute"
-                                    }],
-                            },
-                            type: 2
-                        }],
-                    type: 255,
-                    browserLabel: 'Test Label 123:3648',
-                },
-                {
-                    name: 'Definitely not this'
-                },
-                {
-                    id: 456,
-                    name: 'Test Label 456'
-                }
-            ];
-            const processEventsSpy = jest.spyOn(jabraService, '_processEvents');
-            const deviceSignalsSubject = new rxjs_1.Subject();
-            const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
-            jest.spyOn(jabraService, 'createCallControlFactory').mockReturnValue({
+        }));
+        it('should do nothing if trying to connect', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(jabraService, 'changeConnectionStatus');
+            jabraService.isConnecting = true;
+            yield jabraService.connect('someDevice');
+            expect(statusChangeSpy).not.toHaveBeenCalled();
+        }));
+        it('should connect with previouslyConnectedDevice', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(jabraService, 'changeConnectionStatus');
+            jest.spyOn(jabraService, 'getPreviouslyConnectedDevice').mockResolvedValue(mockDevice2);
+            const callControl = createMockCallControl(new rxjs_1.Subject().asObservable());
+            jest
+                .spyOn(jabraService, 'createCallControlFactory')
+                .mockReturnValue({
                 createCallControl: () => __awaiter(void 0, void 0, void 0, function* () {
                     return callControl;
-                })
+                }),
             });
-            const deviceConnectionStatusChangedSpy = jest.spyOn(jabraService, 'changeConnectionStatus');
-            const requestWebHidPermissionsSpy = jest.spyOn(jabraService, 'requestWebHidPermissions');
-            const testLabel = 'test label 456';
-            jabraService.jabraSdk = jabraSdk;
-            yield jabraService.connect(testLabel);
-            jest.advanceTimersByTime(2100);
-            yield flushPromises();
-            subject.next(testDevices);
-            yield flushPromises();
-            yield flushPromises();
-            // await flushPromises();
-            expect(requestWebHidPermissionsSpy).toHaveBeenCalled();
-            expect(processEventsSpy).toHaveBeenCalledWith(callControl);
-            expect(deviceConnectionStatusChangedSpy).toHaveBeenCalledWith({ isConnected: true, isConnecting: false });
-            expect(jabraService.isConnecting).toBe(false);
-            expect(jabraService.isConnected).toBe(true);
+            yield jabraService.connect(mockDevice2.name);
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: true, isConnecting: false });
         }));
-        it('should have an instance of a CallControlFactory after calling the createCallControlFactory function', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testLabel = 'test label 123';
-            jabraService.jabraSdk = jabraSdk;
-            yield jabraService.connect(testLabel);
-            yield flushPromises();
-            expect(jabraService.callControlFactory instanceof jabra_js_1.CallControlFactory).toBe(true);
+        it('should connect with webhidRequest', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(jabraService, 'changeConnectionStatus');
+            jest.spyOn(jabraService, 'getPreviouslyConnectedDevice').mockResolvedValue(null);
+            const webhidSpy = jest.spyOn(jabraService, 'getDeviceFromWebhid').mockResolvedValue(mockDevice2);
+            const callControl = createMockCallControl(new rxjs_1.Subject().asObservable());
+            jest
+                .spyOn(jabraService, 'createCallControlFactory')
+                .mockReturnValue({
+                createCallControl: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return callControl;
+                }),
+            });
+            yield jabraService.connect(mockDevice2.name);
+            expect(webhidSpy).toHaveBeenCalled();
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: true, isConnecting: false });
+        }));
+        it('should fail to connect and set statuses accordingly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(jabraService, 'changeConnectionStatus');
+            jest.spyOn(jabraService, 'getPreviouslyConnectedDevice').mockResolvedValue(null);
+            const callControlSpy = jest.fn();
+            const callControl = createMockCallControl(new rxjs_1.Subject().asObservable());
+            jest
+                .spyOn(jabraService, 'createCallControlFactory')
+                .mockReturnValue({
+                createCallControl: callControl
+            });
+            const webhidSpy = jest.spyOn(jabraService, 'getDeviceFromWebhid').mockRejectedValue({});
+            yield jabraService.connect(mockDevice2.name);
+            expect(webhidSpy).toHaveBeenCalled();
+            expect(callControlSpy).not.toHaveBeenCalled();
+            expect(statusChangeSpy).lastCalledWith({ isConnected: false, isConnecting: false });
         }));
     });
     describe('processEvents', () => {
@@ -281,6 +204,18 @@ describe('JabraService', () => {
             expect(callControl.ring).toHaveBeenCalledWith(false);
             expect(deviceAnsweredCallSpy).toHaveBeenCalled();
         }));
+        it('offhook should not call deviceAnsweredCall if outboundCall', () => {
+            jabraService.pendingConversationIsOutbound = true;
+            jabraService.callLock = true;
+            const deviceAnsweredCallSpy = jest.spyOn(jabraService, 'deviceAnsweredCall');
+            const deviceSignalsSubject = new rxjs_1.Subject();
+            const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
+            jabraService._processEvents(callControl);
+            deviceSignalsSubject.next({ type: 32, value: true });
+            expect(callControl.offHook).toHaveBeenCalledWith(true);
+            expect(callControl.ring).toHaveBeenCalledWith(false);
+            expect(deviceAnsweredCallSpy).not.toHaveBeenCalled();
+        });
         it('properly handles end call events passed in from headset with a successful callLock release', () => __awaiter(void 0, void 0, void 0, function* () {
             jabraService.callLock = true;
             const deviceEndedCallSpy = jest.spyOn(jabraService, 'deviceEndedCall');
@@ -349,14 +284,25 @@ describe('JabraService', () => {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService._processEvents(callControl);
+            jabraService.activeConversationId = 'myConvo5521';
             deviceSignalsSubject.next({ type: 33, value: true });
             expect(jabraService.isHeld).toBe(true);
             expect(callControl.hold).toHaveBeenCalledWith(true);
-            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith(true, { code: 33, name: 'OnHold' });
+            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith({
+                holdRequested: true,
+                code: 33,
+                name: 'OnHold',
+                conversationId: jabraService.activeConversationId
+            });
             deviceSignalsSubject.next({ type: 35, value: true });
             expect(jabraService.isHeld).toBe(false);
             expect(callControl.hold).toHaveBeenCalledWith(false);
-            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith(false, { code: 35, name: 'ResumeCall' });
+            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith({
+                holdRequested: false,
+                code: 35,
+                name: 'ResumeCall',
+                conversationId: jabraService.activeConversationId
+            });
         }));
         it('properly handles mute call events passed in from headset', () => __awaiter(void 0, void 0, void 0, function* () {
             jabraService.callLock = true;
@@ -364,31 +310,44 @@ describe('JabraService', () => {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService._processEvents(callControl);
+            jabraService.activeConversationId = 'myConvo555521';
             deviceSignalsSubject.next({ type: 47, value: true });
             expect(jabraService.isMuted).toBe(true);
             expect(callControl.mute).toHaveBeenCalledWith(true);
-            expect(deviceMuteChangedSpy).toHaveBeenCalledWith(true, { code: 47, name: 'CallMuted' });
+            expect(deviceMuteChangedSpy).toHaveBeenCalledWith({
+                isMuted: true,
+                code: 47,
+                name: 'CallMuted',
+                conversationId: jabraService.activeConversationId
+            });
             deviceSignalsSubject.next({ type: 47, value: true });
             expect(jabraService.isMuted).toBe(false);
             expect(callControl.mute).toHaveBeenCalledWith(false);
-            expect(deviceMuteChangedSpy).toHaveBeenCalledWith(false, { code: 47, name: 'CallUnmuted' });
+            expect(deviceMuteChangedSpy).toHaveBeenCalledWith({
+                isMuted: false,
+                code: 47,
+                name: 'CallUnmuted',
+                conversationId: jabraService.activeConversationId
+            });
         }));
         it('properly handles reject call events passed in from headset with a successful callLock release', () => __awaiter(void 0, void 0, void 0, function* () {
             jabraService.callLock = true;
-            jabraService.incomingConversationId = 'convoId1234';
+            const conversationId = 'convoId1234';
+            jabraService.pendingConversationId = conversationId;
             const deviceRejectedCallSpy = jest.spyOn(jabraService, 'deviceRejectedCall');
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService._processEvents(callControl);
             deviceSignalsSubject.next({ type: 65533, value: true });
             expect(callControl.ring).toHaveBeenCalledWith(false);
-            expect(deviceRejectedCallSpy).toHaveBeenCalledWith('convoId1234');
+            expect(deviceRejectedCallSpy).toHaveBeenCalledWith({ conversationId, name: 'REJECT_CALL' });
             expect(yield callControl.releaseCallLock).toHaveBeenCalled();
             expect(jabraService.callLock).toBe(false);
         }));
         it('properly handles reject call events passed in from headset with a failed callLock release', () => __awaiter(void 0, void 0, void 0, function* () {
             jabraService.callLock = true;
-            jabraService.incomingConversationId = 'convoId1234';
+            const conversationId = 'convoId124234';
+            jabraService.pendingConversationId = conversationId;
             const deviceRejectedCallSpy = jest.spyOn(jabraService, 'deviceRejectedCall');
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
@@ -405,13 +364,14 @@ describe('JabraService', () => {
             const infoLoggerSpy = jest.spyOn(jabraService.logger, 'info');
             deviceSignalsSubject.next({ type: 65533, value: true });
             expect(callControl.ring).toHaveBeenCalledWith(false);
-            expect(deviceRejectedCallSpy).toHaveBeenCalledWith('convoId1234');
+            expect(deviceRejectedCallSpy).toHaveBeenCalledWith({ conversationId, name: 'REJECT_CALL' });
             expect(yield callControl.releaseCallLock).toHaveBeenCalled();
             expect(infoLoggerSpy).toHaveBeenCalledWith('Trying to release the call lock, but it is not held!');
         }));
         it('properly logs an error that is not related to call lock during reject call flow', () => __awaiter(void 0, void 0, void 0, function* () {
             jabraService.callLock = true;
-            jabraService.incomingConversationId = 'convoId1234';
+            const conversationId = 'convoId1524';
+            jabraService.pendingConversationId = conversationId;
             const deviceRejectedCallSpy = jest.spyOn(jabraService, 'deviceRejectedCall');
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
@@ -428,7 +388,7 @@ describe('JabraService', () => {
             const errorLoggerSpy = jest.spyOn(jabraService.logger, 'error');
             deviceSignalsSubject.next({ type: 65533, value: true });
             expect(callControl.ring).toHaveBeenCalledWith(false);
-            expect(deviceRejectedCallSpy).toHaveBeenCalledWith('convoId1234');
+            expect(deviceRejectedCallSpy).toHaveBeenCalledWith({ conversationId, name: 'REJECT_CALL' });
             expect(yield callControl.releaseCallLock).toHaveBeenCalled();
             expect(errorLoggerSpy).toHaveBeenCalledWith(jabra_js_1.ErrorType.UNEXPECTED_ERROR, 'Something went terribly wrong');
         }));
@@ -491,15 +451,35 @@ describe('JabraService', () => {
         });
     });
     describe('disconnect', () => {
-        it('resets two connected flags after disconnecting', () => {
+        it('resets two connected flags after disconnecting', () => __awaiter(void 0, void 0, void 0, function* () {
             jabraService.isConnected = true;
             jabraService.isConnecting = true;
-            const headsetEventSubscriptionSpy = jest.spyOn(jabraService['headsetEventSubscription'], 'unsubscribe');
-            jabraService.disconnect();
-            expect(headsetEventSubscriptionSpy).toHaveBeenCalled();
+            const unsubscribeSpy = jest.fn();
+            jabraService['headsetEventSubscription'] = {
+                unsubscribe: unsubscribeSpy
+            };
+            yield jabraService.disconnect();
+            expect(unsubscribeSpy).toHaveBeenCalled();
             expect(jabraService.isConnecting).toBe(false);
             expect(jabraService.isConnected).toBe(false);
-        });
+        }));
+        it('should only change connection status if connecting or connected', () => __awaiter(void 0, void 0, void 0, function* () {
+            const connectionSpy = jabraService['changeConnectionStatus'] = jest.fn();
+            jabraService.isConnected = false;
+            jabraService.isConnecting = false;
+            jabraService['headsetEventSubscription'] = {
+                unsubscribe: jest.fn()
+            };
+            yield jabraService.disconnect();
+            expect(connectionSpy).not.toHaveBeenCalled();
+            jabraService.isConnected = true;
+            yield jabraService.disconnect();
+            expect(connectionSpy).toHaveBeenCalled();
+            jabraService.isConnected = false;
+            jabraService.isConnecting = false;
+            yield jabraService.disconnect();
+            expect(connectionSpy).toHaveBeenCalled();
+        }));
     });
     describe('answerCall', () => {
         it('sends answer call event to headset', () => {
@@ -527,20 +507,33 @@ describe('JabraService', () => {
             jabraService.callControl = callControl;
             const callInfo = {
                 conversationId: '123',
-                contactName: 'Lee Moriarty'
+                contactName: 'Lee Moriarty',
             };
             callControl.takeCallLock.mockResolvedValue(true);
             yield jabraService.incomingCall(callInfo);
             expect(jabraService.callLock).toBe(true);
             expect(callControl.ring).toHaveBeenCalledWith(true);
         }));
+        it('should do nothing if no calllock', () => __awaiter(void 0, void 0, void 0, function* () {
+            const deviceSignalsSubject = new rxjs_1.Subject();
+            const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
+            jabraService.callControl = callControl;
+            callControl.takeCallLock.mockResolvedValue(false);
+            const callInfo = {
+                conversationId: '123',
+                contactName: 'Lee Moriarty',
+            };
+            yield jabraService.incomingCall(callInfo);
+            expect(jabraService.callLock).toBe(false);
+            expect(callControl.ring).not.toHaveBeenCalled();
+        }));
         it('sends ring event based on flags after already having callLock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             const callInfo = {
                 conversationId: '456',
-                contactName: 'Adam Cole'
+                contactName: 'Adam Cole',
             };
             callControl.takeCallLock.mockImplementation(() => {
                 throw exceptionWithType('Trying to take the call lock, but it is already held!', jabra_js_1.ErrorType.SDK_USAGE_ERROR);
@@ -556,7 +549,7 @@ describe('JabraService', () => {
             jabraService.callControl = callControl;
             const callInfo = {
                 conversationId: '789',
-                contactName: 'Gene Ween'
+                contactName: 'Gene Ween',
             };
             callControl.takeCallLock.mockImplementation(() => {
                 throw exceptionWithType('An actual error', jabra_js_1.ErrorType.UNEXPECTED_ERROR);
@@ -573,10 +566,20 @@ describe('JabraService', () => {
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             callControl.takeCallLock.mockResolvedValue(true);
-            yield jabraService.outgoingCall();
+            yield jabraService.outgoingCall({ conversationId: 'myconvoid1' });
             expect(jabraService.callLock).toBe(true);
             expect(callControl.offHook).toHaveBeenCalledWith(true);
         }));
+        it('does nothing if callLock is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            const deviceSignalsSubject = new rxjs_1.Subject();
+            const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
+            callControl.takeCallLock.mockResolvedValue(false);
+            jabraService.callControl = callControl;
+            yield jabraService.outgoingCall({ conversationId: 'myconvoid2' });
+            expect(jabraService.callLock).toBe(false);
+            expect(jabraService.activeConversationId).toBeFalsy();
+            expect(callControl.offHook).not.toHaveBeenCalled();
+        }));
         it('sends ring event while already in possession of callLock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
@@ -585,7 +588,7 @@ describe('JabraService', () => {
                 throw exceptionWithType('Trying to take the call lock, but it is already held!', jabra_js_1.ErrorType.SDK_USAGE_ERROR);
             });
             const infoLoggerSpy = jest.spyOn(jabraService.logger, 'info');
-            yield jabraService.outgoingCall();
+            yield jabraService.outgoingCall({ conversationId: 'myconvoid2' });
             expect(infoLoggerSpy).toHaveBeenCalledWith('Trying to take the call lock, but it is already held!');
             expect(callControl.offHook).toHaveBeenCalledWith(true);
         }));
@@ -597,37 +600,35 @@ describe('JabraService', () => {
                 throw exceptionWithType('An actual error', jabra_js_1.ErrorType.UNEXPECTED_ERROR);
             });
             const errorLoggerSpy = jest.spyOn(jabraService.logger, 'error');
-            yield jabraService.outgoingCall();
+            yield jabraService.outgoingCall({ conversationId: 'myconvoid3' });
             expect(errorLoggerSpy).toHaveBeenCalledWith(jabra_js_1.ErrorType.UNEXPECTED_ERROR, 'An actual error');
             expect(callControl.offHook).not.toHaveBeenCalled();
         }));
     });
     describe('rejectCall', () => {
-        it('properly sends ring events and releases call lock', () => {
+        it('properly sends ring events and releases call lock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             const resetStateSpy = jest.spyOn(jabraService, 'resetState');
             jabraService.callLock = true;
-            const jabraRejectCall = jabraService.rejectCall();
+            yield jabraService.rejectCall();
             expect(callControl.ring).toHaveBeenCalledWith(false);
             expect(callControl.releaseCallLock).toHaveBeenCalled();
             expect(jabraService.callLock).toBe(false);
             expect(resetStateSpy).toHaveBeenCalled();
-            expect(jabraRejectCall).resolves.toReturn();
-        });
-        it('prints out message if not in possession of callLock', () => {
+        }));
+        it('prints out message if not in possession of callLock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             const infoLoggerSpy = jest.spyOn(jabraService.logger, 'info');
             const resetStateSpy = jest.spyOn(jabraService, 'resetState');
-            const jabraRejectCall = jabraService.rejectCall();
+            yield jabraService.rejectCall();
             expect(infoLoggerSpy).toHaveBeenCalledWith('Currently not in possession of the Call Lock; Cannot react to Device Actions');
             expect(jabraService.callLock).toBe(false);
             expect(resetStateSpy).toHaveBeenCalled();
-            expect(jabraRejectCall).resolves.toReturn();
-        });
+        }));
         it('properly handles flow when in possession of callLock', () => {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
@@ -657,39 +658,38 @@ describe('JabraService', () => {
         });
     });
     describe('endCall', () => {
-        it('properly sends offHook events and releases call lock', () => {
+        it('properly sends offHook events and releases call lock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
+            jabraService.activeConversationId = '123';
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             const resetStateSpy = jest.spyOn(jabraService, 'resetState');
             jabraService.callLock = true;
-            const jabraEndCalls = jabraService.endCall('123', false);
+            yield jabraService.endCall('123', false);
             expect(callControl.offHook).toHaveBeenCalledWith(false);
             expect(callControl.releaseCallLock).toHaveBeenCalled();
             expect(jabraService.callLock).toBe(false);
             expect(resetStateSpy).toHaveBeenCalled();
-            expect(jabraEndCalls).resolves.toReturn();
-        });
-        it('properly resolves if another call is already in place', () => {
+            expect(jabraService.activeConversationId).toBeNull();
+        }));
+        it('properly resolves if another call is already in place', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
-            const jabraEndCalls = jabraService.endCall('123', true);
-            expect(jabraEndCalls).resolves.toReturn();
+            yield jabraService.endCall('123', true);
             expect(callControl.offHook).not.toHaveBeenCalled();
-        });
-        it('prints out message if not in possession of callLock', () => {
+        }));
+        it('prints out message if not in possession of callLock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             const infoLoggerSpy = jest.spyOn(jabraService.logger, 'info');
             const resetStateSpy = jest.spyOn(jabraService, 'resetState');
-            const jabraEndCalls = jabraService.endCall('123', false);
+            yield jabraService.endCall('123', false);
             expect(infoLoggerSpy).toHaveBeenCalledWith('Currently not in possession of the Call Lock; Cannot react to Device Actions');
             expect(jabraService.callLock).toBe(false);
             expect(resetStateSpy).toHaveBeenCalled();
-            expect(jabraEndCalls).resolves.toReturn();
-        });
+        }));
         it('properly handles flow when in possession of callLock', () => {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
@@ -719,31 +719,29 @@ describe('JabraService', () => {
         });
     });
     describe('endAllCall', () => {
-        it('properly sends offHook events and releases call lock', () => {
+        it('properly sends offHook events and releases call lock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             const resetStateSpy = jest.spyOn(jabraService, 'resetState');
             jabraService.callLock = true;
-            const jabraEndCalls = jabraService.endAllCalls();
+            yield jabraService.endAllCalls();
             expect(callControl.offHook).toHaveBeenCalledWith(false);
             expect(callControl.releaseCallLock).toHaveBeenCalled();
             expect(jabraService.callLock).toBe(false);
             expect(resetStateSpy).toHaveBeenCalled();
-            expect(jabraEndCalls).resolves.toReturn();
-        });
-        it('prints out message if not in possession of callLock', () => {
+        }));
+        it('prints out message if not in possession of callLock', () => __awaiter(void 0, void 0, void 0, function* () {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
             jabraService.callControl = callControl;
             const infoLoggerSpy = jest.spyOn(jabraService.logger, 'info');
             const resetStateSpy = jest.spyOn(jabraService, 'resetState');
-            const jabraEndCalls = jabraService.endAllCalls();
+            yield jabraService.endAllCalls();
             expect(infoLoggerSpy).toHaveBeenCalledWith('Currently not in possession of the Call Lock; Cannot react to Device Actions');
             expect(jabraService.callLock).toBe(false);
             expect(resetStateSpy).toHaveBeenCalled();
-            expect(jabraEndCalls).resolves.toReturn();
-        });
+        }));
         it('properly handles flow when in possession of callLock', () => {
             const deviceSignalsSubject = new rxjs_1.Subject();
             const callControl = createMockCallControl(deviceSignalsSubject.asObservable());
@@ -773,41 +771,45 @@ describe('JabraService', () => {
         });
     });
     describe('deviceInfo', () => {
-        it('should return null if activeDeviceId is null', () => {
-            jabraService.devices.set(testDevice1.deviceName, testDevice1);
-            jabraService.activeDeviceId = null;
-            const result = jabraService.deviceInfo;
-            expect(result).toBeNull();
-        });
-        it('should return null if there are no devices registered', () => {
-            jabraService.activeDeviceId = 'foobar';
-            const result = jabraService.deviceInfo;
-            expect(result).toBeNull();
-        });
-        it('should return a device when it is registered and matches the activeDeviceId', () => {
-            jabraService.activeDeviceId = testDevice1.deviceName;
-            jabraService.devices.set(testDevice1.deviceName, testDevice1);
-            jabraService.devices.set(testDevice2.deviceName, testDevice2);
-            const result = jabraService.deviceInfo;
-            expect(result).toBe(testDevice1);
+        it('should return _deviceInfo', () => {
+            const device = {
+                ProductName: 'myJabra',
+                deviceId: '123',
+                attached: true,
+            };
+            jabraService._deviceInfo = device;
+            expect(jabraService.deviceInfo).toBe(device);
         });
     });
     describe('deviceName', () => {
         it('should return the deviceName of the active device', () => {
-            populateDevices(jabraService);
-            jabraService.activeDeviceId = testDevice1.deviceName;
-            expect(jabraService.deviceName).toEqual(testDevice1.deviceName);
+            const device = {
+                ProductName: 'myJabra',
+                deviceName: 'myJabraName',
+                deviceId: '123',
+                attached: true,
+            };
+            jabraService._deviceInfo = device;
+            expect(jabraService.deviceName).toBe(device.deviceName);
+        });
+        it('should return falsey value if no deviceInfo', () => {
+            jabraService._deviceInfo = null;
+            expect(jabraService.deviceName).toBeUndefined();
         });
     });
     describe('isDeviceAttached', () => {
-        it('should return true if the the device is in the devices list is the activeDeviceId', () => {
-            populateDevices(jabraService);
-            jabraService.activeDeviceId = testDevice1.deviceName;
+        it('should return true if there is deviceInfo', () => {
+            const device = {
+                ProductName: 'myJabra',
+                deviceName: 'myJabraName',
+                deviceId: '123',
+                attached: true,
+            };
+            jabraService._deviceInfo = device;
             expect(jabraService.isDeviceAttached).toEqual(true);
         });
-        it('should return false if the the device is NOT in the devices list is the activeDeviceId', () => {
-            populateDevices(jabraService);
-            jabraService.activeDeviceId = 'Imaginary Device';
+        it('should return false if no deviceInfo', () => {
+            jabraService._deviceInfo = null;
             expect(jabraService.isDeviceAttached).toEqual(false);
         });
     });
@@ -826,19 +828,130 @@ describe('JabraService', () => {
         });
         it('should return false if name within device is undefined', () => {
             const testDevice = {
-                type: "Test",
-                id: '123'
+                type: 'Test',
+                id: '123',
             };
             expect(jabraService.isDeviceInList(testDevice, 'Test Label 123')).toBe(false);
         });
         it('should return true if all expected values are present and the label matches', () => {
             const testDevice = {
-                type: "Test",
+                type: 'Test',
                 id: '123',
-                name: 'Test Label 123'
+                name: 'Test Label 123',
             };
             expect(jabraService.isDeviceInList(testDevice, 'test label 123')).toBe(true);
         });
     });
+    describe('resetHeadsetState', () => {
+        it('should handle reset being called without a callControl', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield jabraService.resetHeadsetState();
+            // if the above didn't blow up, we are happy
+            expect(true).toBeTruthy();
+        }));
+        it('should reset state if there is a callControl', () => __awaiter(void 0, void 0, void 0, function* () {
+            const callControl = createMockCallControl(null);
+            jabraService.callControl = callControl;
+            yield jabraService.resetHeadsetState();
+            expect(callControl.hold).toHaveBeenCalledWith(false);
+            expect(callControl.mute).toHaveBeenCalledWith(false);
+            expect(callControl.offHook).toHaveBeenCalledWith(false);
+        }));
+    });
+    describe('getDeviceFromWebhid', () => {
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it('should return matching value from deviceList', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sub = new rxjs_1.BehaviorSubject([mockDevice1]);
+            jabraService.jabraSdk = (yield initializeSdk(sub));
+            const requestSpy = jabraService.requestWebHidPermissions = jest.fn();
+            const completionSpy = jest.fn();
+            const devicePromise = jabraService.getDeviceFromWebhid(mockDevice2.name)
+                .then((device) => {
+                completionSpy();
+                return device;
+            });
+            yield flushPromises();
+            expect(requestSpy).toHaveBeenCalled();
+            expect(completionSpy).not.toBeCalled();
+            sub.next([mockDevice1, mockDevice2]);
+            const device = yield devicePromise;
+            expect(device).toBe(mockDevice2);
+        }));
+        it('should timeout after 30 seconds', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.useFakeTimers();
+            const sub = new rxjs_1.BehaviorSubject([mockDevice1]);
+            jabraService.jabraSdk = (yield initializeSdk(sub));
+            const requestSpy = jabraService.requestWebHidPermissions = jest.fn();
+            const devicePromise = jabraService.getDeviceFromWebhid(mockDevice2.name);
+            yield flushPromises();
+            expect(requestSpy).toHaveBeenCalled();
+            jest.advanceTimersByTime(30100);
+            yield expect(devicePromise).rejects.toThrow('not granted WebHID permissions');
+        }));
+        it('should log random error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sub = new rxjs_1.BehaviorSubject([mockDevice1]);
+            jabraService.jabraSdk = (yield initializeSdk(sub));
+            const requestSpy = jabraService.requestWebHidPermissions = jest.fn();
+            const devicePromise = jabraService.getDeviceFromWebhid(mockDevice2.name);
+            yield flushPromises();
+            expect(requestSpy).toHaveBeenCalled();
+            sub.error(new Error('random error'));
+            yield expect(devicePromise).rejects.toThrow('random error');
+        }));
+    });
+    describe('getPreviouslyConnectedDevice', () => {
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it('should return matching value from deviceList', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sub = new rxjs_1.BehaviorSubject([]);
+            jabraService.jabraSdk = (yield initializeSdk(sub));
+            const completionSpy = jest.fn();
+            const devicePromise = jabraService.getPreviouslyConnectedDevice(mockDevice2.name)
+                .then((device) => {
+                completionSpy();
+                return device;
+            });
+            yield flushPromises();
+            expect(completionSpy).not.toBeCalled();
+            sub.next([mockDevice1, mockDevice2]);
+            const device = yield devicePromise;
+            expect(device).toBe(mockDevice2);
+        }));
+        it('should return null', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sub = new rxjs_1.BehaviorSubject([mockDevice1]);
+            jabraService.jabraSdk = (yield initializeSdk(sub));
+            const completionSpy = jest.fn();
+            const devicePromise = jabraService.getPreviouslyConnectedDevice(mockDevice2.name)
+                .then((device) => {
+                completionSpy();
+                return device;
+            });
+            yield flushPromises();
+            expect(completionSpy).not.toBeCalled();
+            sub.next([mockDevice1, mockDevice2]);
+            const device = yield devicePromise;
+            expect(device).toBeNull();
+        }));
+        it('should timeout after 3 seconds', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.useFakeTimers();
+            const sub = new rxjs_1.BehaviorSubject([]);
+            jabraService.jabraSdk = (yield initializeSdk(sub));
+            const devicePromise = jabraService.getPreviouslyConnectedDevice(mockDevice2.name);
+            yield flushPromises();
+            jest.advanceTimersByTime(3100);
+            const device = yield devicePromise;
+            expect(device).toBeFalsy();
+        }));
+        it('should log random error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sub = new rxjs_1.BehaviorSubject([]);
+            jabraService.jabraSdk = (yield initializeSdk(sub));
+            const devicePromise = jabraService.getPreviouslyConnectedDevice(mockDevice2.name);
+            yield flushPromises();
+            sub.error(new Error('random error'));
+            yield expect(devicePromise).rejects.toThrow('random error');
+        }));
+    });
 });
 //# sourceMappingURL=jabra.test.js.map