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

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

@@ -0,0 +1,983 @@
+"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 });
+// import fetchJsonp from 'fetch-jsonp';
+require("whatwg-fetch");
+const plantronics_test_responses_1 = __importDefault(require("./plantronics-test-responses"));
+require("regenerator-runtime");
+const broadcast_channel_1 = require("broadcast-channel");
+const browserama_1 = __importDefault(require("browserama"));
+const test_utils_1 = require("../../../test-utils");
+const plantronics_1 = __importDefault(require("./plantronics"));
+const fetch_jsonp_1 = __importDefault(require("fetch-jsonp"));
+jest.mock('broadcast-channel');
+jest.mock('fetch-jsonp', () => jest.fn());
+const mockPlantronicsHost = 'http://localhost:3000/plantronics';
+const testDevice = {
+    ProductName: 'testDevice1',
+};
+const originalFetchFunction = plantronics_1.default.getInstance({ logger: console })._fetch;
+function resetService(plantronicsService) {
+    plantronicsService.apiHost = mockPlantronicsHost;
+    plantronicsService.vendorName = 'Plantronics';
+    plantronicsService.pluginName = 'genesys-cloud-headset-library';
+    plantronicsService._deviceInfo = null;
+    plantronicsService.activePollingInterval = 2000;
+    plantronicsService.connectedDeviceInterval = 6000;
+    plantronicsService.disconnectedDeviceInterval = 2000;
+    plantronicsService.deviceIdRetryInterval = 2000;
+    plantronicsService.isActive = false;
+    plantronicsService.isConnected = false;
+    plantronicsService.isConnecting = false;
+    plantronicsService.disableEventPolling = false;
+    plantronicsService.deviceStatusTimer = null;
+}
+function buildMockFetch(response, isOk) {
+    return new Promise((resolve) => {
+        resolve({
+            ok: isOk,
+            json: () => {
+                return response;
+            },
+        });
+    });
+}
+let callbackCount = 1;
+describe('PlantronicsService', () => {
+    let plantronicsService;
+    beforeEach(() => {
+        plantronicsService = plantronics_1.default.getInstance({ logger: console, createNew: true });
+        plantronicsService._fetch = (url) => {
+            const fullUrl = `${url}&callback=${callbackCount++}`;
+            return fetch(fullUrl, {
+                method: 'get',
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        };
+    });
+    describe('instantiation', () => {
+        afterEach(() => {
+            plantronicsService = null;
+        });
+        it('should be a singleton', () => {
+            const plantronicsService2 = plantronics_1.default.getInstance({ logger: console });
+            expect(plantronicsService).not.toBeFalsy();
+            expect(plantronicsService2).not.toBeFalsy();
+            expect(plantronicsService).toBe(plantronicsService2);
+        });
+    });
+    describe('deviceName', () => {
+        it('should return the value of deviceInfo.ProductName', () => {
+            plantronicsService._deviceInfo = testDevice;
+            const result = plantronicsService.deviceName;
+            expect(result).toEqual(testDevice.ProductName);
+        });
+        it('should return undefined if _deviceInfo is undefined', () => {
+            plantronicsService._deviceInfo = undefined;
+            const result = plantronicsService.deviceName;
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('vendorName', () => {
+        it('should return the expected name', () => {
+            const expected = 'Plantronics';
+            expect(plantronicsService.vendorName).toEqual(expected);
+        });
+    });
+    describe('deviceLabelMatchesVendor', () => {
+        beforeEach(() => {
+            plantronicsService = plantronics_1.default.getInstance({ logger: console });
+            plantronicsService.logger = test_utils_1.mockLogger;
+        });
+        it('should return true when the device label contains the string "plantronics"', () => {
+            let testLabel = 'plantronics headset';
+            let result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset PlanTroniCs made';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset of Plantronics';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+        });
+        it('should return false when the device label does not contain the string "plantronics"', () => {
+            let testLabel = 'standard headset';
+            let result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset sennheiser made';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset of awesome';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+        });
+        it('should return true when device label contains the string "plt"', () => {
+            let testLabel = 'plt: a sandwich';
+            let result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'test test PlT';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'test pLt test';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+        });
+        it('should return false when device label does not contain the string "plt"', () => {
+            const testLabel = 'standard headset';
+            const result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+        });
+        it('should return true when the device label contains the string "(047f:"', () => {
+            let testLabel = '(047f: headset';
+            let result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset (047f: made';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+            testLabel = 'A headset of (047f:';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(true);
+        });
+        it('should return false when the device label does not contain the string "(047f:"', () => {
+            let testLabel = 'standard headset';
+            let result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset sennheiser made';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+            testLabel = 'A headset of awesome';
+            result = plantronicsService.deviceLabelMatchesVendor(testLabel);
+            expect(result).toBe(false);
+        });
+    });
+    describe('pollForCallEvents', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+        });
+        afterEach(() => {
+            jest.runOnlyPendingTimers();
+            jest.useRealTimers();
+        });
+        it('will not call getCallEventsSpy if proper flags are not met', () => {
+            const getCallEventsSpy = jest.spyOn(plantronicsService, 'getCallEvents');
+            const pollForCallEventsSpy = jest.spyOn(plantronicsService, 'pollForCallEvents');
+            plantronicsService.pollForCallEvents();
+            pollForCallEventsSpy.mockReset();
+            expect(getCallEventsSpy).not.toHaveBeenCalled();
+            jest.advanceTimersByTime(plantronicsService.activePollingInterval);
+            expect(pollForCallEventsSpy).toHaveBeenCalled();
+        });
+        it('will call getCallEventsSpy if proper flags are met', () => {
+            const getCallEventsSpy = jest.spyOn(plantronicsService, 'getCallEvents');
+            plantronicsService.isConnected = true;
+            plantronicsService.isActive = true;
+            plantronicsService.disableEventPolling = false;
+            plantronicsService.pollForCallEvents();
+            expect(getCallEventsSpy).toHaveBeenCalled();
+            jest.advanceTimersByTime(plantronicsService.activePollingInterval);
+        });
+    });
+    describe('pollForDeviceStatus', () => {
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it('will not call getDeviceStatusSpy if proper flags are not met', () => {
+            plantronicsService.isConnecting = true;
+            const getDeviceStatusSpy = jest.spyOn(plantronicsService, 'getDeviceStatus');
+            const pollForDeviceStatusSpy = jest.spyOn(plantronicsService, 'pollForDeviceStatus');
+            jest.useFakeTimers();
+            plantronicsService.pollForDeviceStatus();
+            expect(getDeviceStatusSpy).not.toHaveBeenCalled();
+            jest.advanceTimersByTime(plantronicsService.disconnectedDeviceInterval);
+            expect(pollForDeviceStatusSpy).toHaveBeenCalled();
+        });
+        it('will call getDeviceStatusSpy if proper flags are met', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isConnected = true;
+            plantronicsService.isConnecting = false;
+            const getDeviceStatusSpy = jest.spyOn(plantronicsService, 'getDeviceStatus');
+            const pollForDeviceStatusSpy = jest.spyOn(plantronicsService, 'pollForDeviceStatus');
+            jest.useFakeTimers();
+            plantronicsService.pollForDeviceStatus();
+            expect(getDeviceStatusSpy).toHaveBeenCalled();
+            jest.advanceTimersByTime(plantronicsService.disconnectedDeviceInterval);
+            expect(pollForDeviceStatusSpy).toHaveBeenCalled();
+        }));
+        it('will use connectedDeviceInterval if a device is attached', () => {
+            plantronicsService.isConnected = true;
+            plantronicsService.isConnecting = false;
+            const getDeviceStatusSpy = jest.spyOn(plantronicsService, 'getDeviceStatus');
+            const pollForDeviceStatusSpy = jest.spyOn(plantronicsService, 'pollForDeviceStatus');
+            Object.defineProperty(plantronicsService, 'isDeviceAttached', { get: () => { return true; } });
+            jest.useFakeTimers();
+            plantronicsService.pollForDeviceStatus();
+            expect(getDeviceStatusSpy).toHaveBeenCalled();
+            jest.advanceTimersByTime(plantronicsService.connectedDeviceInterval);
+            expect(pollForDeviceStatusSpy).toHaveBeenCalled();
+            const timeoutSpy = jest.spyOn(window, 'setTimeout');
+            plantronicsService.pollForDeviceStatus();
+            expect(timeoutSpy).toHaveBeenCalledWith(expect.anything(), plantronicsService.connectedDeviceInterval);
+            timeoutSpy.mockRestore();
+        });
+    });
+    describe('callCorrespondingFunction', () => {
+        it('will call deviceAnsweredCall', () => {
+            const deviceAnsweredCallSpy = jest.spyOn(plantronicsService, 'deviceAnsweredCall');
+            plantronicsService.callCorrespondingFunction({
+                name: 'AcceptCall',
+                code: '1',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(deviceAnsweredCallSpy).toHaveBeenCalled();
+        });
+        it('will call deviceRejectedCall', () => {
+            plantronicsService.incomingConversationId = 'convoId1234';
+            const deviceRejectedCallSpy = jest.spyOn(plantronicsService, 'deviceRejectedCall');
+            plantronicsService.callCorrespondingFunction({
+                name: 'RejectCall',
+                code: '23',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(deviceRejectedCallSpy).toHaveBeenCalledWith({ conversationId: 'convoId1234', name: 'RejectCall' });
+        });
+        it('will call deviceEndedCall', () => {
+            const deviceEndedCallSpy = jest.spyOn(plantronicsService, 'deviceEndedCall');
+            plantronicsService.callCorrespondingFunction({
+                name: 'TerminateCall',
+                event: {
+                    CallId: {
+                        Id: '123456',
+                    }
+                }
+            });
+            expect(deviceEndedCallSpy).toHaveBeenCalled();
+        });
+        it('will call _checkIsActiveTask', () => {
+            const _checkIsActiveTaskSpy = jest.spyOn(plantronicsService, '_checkIsActiveTask');
+            plantronicsService.callCorrespondingFunction({
+                name: 'CallEnded',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(_checkIsActiveTaskSpy).toHaveBeenCalled();
+        });
+        it('will call deviceMuteChanged with the proper flag', () => {
+            plantronicsService.callMappings = { '123456': 'convo1234' };
+            const deviceMuteChangedSpy = jest.spyOn(plantronicsService, 'deviceMuteChanged');
+            plantronicsService.callCorrespondingFunction({
+                name: 'Mute',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(deviceMuteChangedSpy).toHaveBeenCalledWith({
+                conversationId: 'convo1234',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    },
+                },
+                isMuted: true,
+                name: 'Mute'
+            });
+            plantronicsService.callCorrespondingFunction({
+                name: 'Unmute',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(deviceMuteChangedSpy).toHaveBeenCalledWith({
+                conversationId: 'convo1234',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    },
+                },
+                isMuted: false,
+                name: 'Unmute'
+            });
+        });
+        it('will call deviceHoldStatusChanged with the proper flag', () => {
+            plantronicsService.callMappings = { '123456': 'convo1234' };
+            const deviceHoldStatusChangedSpy = jest.spyOn(plantronicsService, 'deviceHoldStatusChanged');
+            plantronicsService.callCorrespondingFunction({
+                name: 'HoldCall',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith({
+                conversationId: 'convo1234',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    },
+                },
+                holdRequested: true,
+                name: 'HoldCall'
+            });
+            plantronicsService.callCorrespondingFunction({
+                name: 'ResumeCall',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith({
+                conversationId: 'convo1234',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    },
+                },
+                holdRequested: false,
+                name: 'ResumeCall'
+            });
+        });
+        it('calls deviceEventLogs when no valid event was passed in', () => {
+            const deviceEventLogsSpy = jest.spyOn(plantronicsService, 'deviceEventLogs');
+            plantronicsService.callCorrespondingFunction({
+                name: 'Test',
+                event: {
+                    CallId: {
+                        Id: '123456'
+                    }
+                }
+            });
+            expect(deviceEventLogsSpy).toHaveBeenCalled();
+        });
+    });
+    describe('check various endpoint calls', () => {
+        Object.defineProperty(window.navigator, 'hid', { get: () => ({
+                getDevices: () => { return []; }
+            }) });
+        Object.defineProperty(window.navigator, 'locks', { get: () => ({}) });
+        window.BroadcastChannel = broadcast_channel_1.BroadcastChannel;
+        it('connects properly with a clean state', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/Register')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.Register.default, true);
+                }
+                if (url.includes('/SessionManager/IsActive')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.IsActive.default, true);
+                }
+                if (url.includes('/UserPreference/SetDefaultSoftphone')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.UserPreference.SetDefaultSoftPhone.default, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.default, true);
+                }
+                if (url.includes('/CallServices/CallManagerState')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallManagerState.default, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            yield plantronicsService.connect();
+            expect(plantronicsService.isConnected).toBeTruthy();
+            expect(plantronicsService.isActive).toBeFalsy();
+            expect(plantronicsService.isConnecting).toBeFalsy();
+        }), 30000);
+        it('builds an endpoint for incoming calls', () => __awaiter(void 0, void 0, void 0, function* () {
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.default, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            let callInfo = { conversationId: 'convoId123', contactName: 'Dio Brando' };
+            plantronicsService['_createCallMapping'] = jest.fn().mockReturnValue(12345678);
+            const conversationIdString = `"Id":"${12345678}"`;
+            const contactNameString = `"Name":"${callInfo.contactName}"`;
+            const endpointParams = `?name=${plantronicsService.pluginName}&tones=Unknown&route=ToHeadset`;
+            let completeEndpoint = endpointParams;
+            completeEndpoint += `&callID={${encodeURI(conversationIdString)}}`;
+            completeEndpoint += `&contact={${encodeURI(contactNameString)}}`;
+            yield plantronicsService.incomingCall(callInfo);
+            expect(plantronicsService.isActive).toBe(true);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/IncomingCall${completeEndpoint}`);
+            resetService(plantronicsService);
+            completeEndpoint = endpointParams;
+            completeEndpoint += `&callID={${encodeURI(conversationIdString)}}`;
+            callInfo = { conversationId: 'convoId123' };
+            yield plantronicsService.incomingCall(callInfo);
+            expect(plantronicsService.isActive).toBe(true);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/IncomingCall${completeEndpoint}`);
+            resetService(plantronicsService);
+            try {
+                callInfo = { contactName: 'Dio Brando' };
+                yield plantronicsService.incomingCall(callInfo);
+            }
+            catch (err) {
+                expect(plantronicsService.isActive).toBe(false);
+                expect(err).toBeDefined();
+            }
+        }));
+        it('builds an endpoint for outgoing calls', () => __awaiter(void 0, void 0, void 0, function* () {
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/OutgoingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.OutgoingCall.default, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.default, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            let callInfo = { conversationId: 'convoId123', contactName: 'Dio Brando' };
+            plantronicsService['_createCallMapping'] = jest.fn().mockReturnValue(12345678);
+            const conversationIdString = `"Id":"12345678"`;
+            const contactNameString = `"Name":"${callInfo.contactName}"`;
+            const endpointParams = `?name=${plantronicsService.pluginName}&tones=Unknown&route=ToHeadset`;
+            let completeEndpoint = endpointParams;
+            completeEndpoint += `&callID={${encodeURI(conversationIdString)}}`;
+            completeEndpoint += `&contact={${encodeURI(contactNameString)}}`;
+            yield plantronicsService.outgoingCall(Object.assign({}, callInfo));
+            expect(plantronicsService.isActive).toBe(true);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/OutgoingCall${completeEndpoint}`);
+            resetService(plantronicsService);
+            completeEndpoint = endpointParams;
+            completeEndpoint += `&callID={${encodeURI(conversationIdString)}}`;
+            callInfo = { conversationId: 'convoId123' };
+            yield plantronicsService.outgoingCall(Object.assign({}, callInfo));
+            expect(plantronicsService.isActive).toBe(true);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/OutgoingCall${completeEndpoint}`);
+            resetService(plantronicsService);
+            try {
+                callInfo = { contactName: 'Dio Brando' };
+                yield plantronicsService.outgoingCall(Object.assign({}, callInfo));
+            }
+            catch (err) {
+                expect(plantronicsService.isActive).toBe(false);
+                expect(err).toBeDefined();
+            }
+        }));
+        it('builds an endpoint for answering a call', () => __awaiter(void 0, void 0, void 0, function* () {
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/AnswerCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.AnswerCall.default, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.default, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.callMappings = {
+                'convoId123': '12345678'
+            };
+            const conversationIdString = encodeURI(`"Id":"12345678"`);
+            let completeEndpoint = `?name=${plantronicsService.pluginName}`;
+            completeEndpoint += `&callID={${conversationIdString}}`;
+            yield plantronicsService.answerCall('convoId123');
+            expect(plantronicsService.isActive).toBe(true);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/AnswerCall${completeEndpoint}`);
+        }));
+        it('builds an endpoint for terminating a call', () => __awaiter(void 0, void 0, void 0, function* () {
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
+            const getCallEventsSpy = jest.spyOn(plantronicsService, 'getCallEvents');
+            const _checkIsActiveTaskSpy = jest.spyOn(plantronicsService, '_checkIsActiveTask');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/TerminateCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.TerminateCall.default, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.default, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            const conversationId = 'myConvoId12345';
+            const callId = 555123;
+            plantronicsService.callMappings = {
+                [conversationId]: callId,
+                [callId]: conversationId
+            };
+            const conversationIdString = encodeURI(`"Id":"${callId}"`);
+            let completeEndpoint = `?name=${plantronicsService.pluginName}`;
+            completeEndpoint += `&callID={${conversationIdString}}`;
+            yield plantronicsService.endCall(conversationId);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/TerminateCall${completeEndpoint}`);
+            expect(getCallEventsSpy).toHaveBeenCalled();
+            expect(_checkIsActiveTaskSpy).toHaveBeenCalled();
+        }));
+        it('calls endCall an appropriate number of times for endAllCalls', () => __awaiter(void 0, void 0, void 0, function* () {
+            const endCallSpy = jest.spyOn(plantronicsService, 'endCall');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/CallManagerState')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallManagerState.callsInProgress, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            yield plantronicsService.endAllCalls();
+            expect(endCallSpy).toHaveBeenCalledTimes(2);
+        }));
+        it('properly calls endCall in the case of call rejection', () => {
+            plantronicsService.incomingConversationId = 'convoId1234';
+            const plantronicsEndCallSpy = jest.spyOn(plantronicsService, 'endCall');
+            plantronicsService.rejectCall('convoId1234');
+            expect(plantronicsService.incomingConversationId).toBe(null);
+            expect(plantronicsEndCallSpy).toHaveBeenCalledWith('convoId1234');
+        });
+        it('calls _makeRequestTask wth proper endpoint for mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/MuteCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.MuteCall[url.includes('&muted=true') ? 'mute' : 'unmute'], true);
+                }
+                return buildMockFetch({}, true);
+            });
+            yield plantronicsService.setMute(true);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/MuteCall?name=${plantronicsService.pluginName}&muted=${true}`);
+            yield plantronicsService.setMute(false);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/MuteCall?name=${plantronicsService.pluginName}&muted=${false}`);
+        }));
+        it('calls _makeRequestTask with proper endpoint for hold', () => __awaiter(void 0, void 0, void 0, function* () {
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/HoldCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.HoldCall.default, true);
+                }
+                if (url.includes('/CallServices/ResumeCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.ResumeCall.default, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.callMappings = {
+                "convoId123": '12345678'
+            };
+            const conversationIdString = encodeURI(`"Id":"12345678"`);
+            let completeEndpoint = `?name=${plantronicsService.pluginName}`;
+            completeEndpoint += `&callID={${conversationIdString}}`;
+            yield plantronicsService.setHold('convoId123', true);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/HoldCall${completeEndpoint}`);
+            yield plantronicsService.setHold('convoId123', false);
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/ResumeCall${completeEndpoint}`);
+        }));
+        it('checkIsActiveTask', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/CallManagerState')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallManagerState.callsInProgress, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            yield plantronicsService._checkIsActiveTask();
+            expect(plantronicsService.isActive).toBe(true);
+        }));
+        it('catches the error during _getActiveCalls', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/CallManagerState')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallManagerState.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.logger.info = jest.fn();
+            const result = yield plantronicsService._getActiveCalls();
+            expect(plantronicsService.logger.info).toHaveBeenCalledWith('Error making request for active calls', plantronics_test_responses_1.default.CallServices.CallManagerState.errorState);
+            expect(result).toStrictEqual([]);
+        }));
+        it('catches the error during getDeviceStatus', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.logger.info = jest.fn();
+            yield plantronicsService.getDeviceStatus();
+            expect(plantronicsService.logger.info).toHaveBeenCalledWith('Error making request for device status', plantronics_test_responses_1.default.DeviceServices.Info.errorState);
+        }));
+        it('if noDeviceError is true, do not log', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.noDeviceErrorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.logger.info = jest.fn();
+            yield plantronicsService.getDeviceStatus();
+            expect(plantronicsService.logger.info).not.toHaveBeenCalledWith('Error making request for device status', plantronics_test_responses_1.default.DeviceServices.Info.errorState);
+        }));
+        it('handles scenarios for getCallEvents function', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+        }));
+    });
+    describe('getCallEvents', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+            jest.clearAllMocks();
+        });
+        it('should answer from headset', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/CallServices/CallEvents')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallEvents.AnsweredCall, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+            plantronicsService.getCallEvents();
+            const deviceAnswered = (0, test_utils_1.eventValidation)(plantronicsService, 'deviceAnsweredCall');
+            yield deviceAnswered;
+        }));
+        it('should mute from headset', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/CallServices/CallEvents')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallEvents.MuteCall, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+            plantronicsService.getCallEvents();
+            const deviceMuted = (0, test_utils_1.eventValidation)(plantronicsService, 'deviceMuteChanged');
+            yield deviceMuted;
+        }));
+        it('should unmute from headset', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/CallServices/CallEvents')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallEvents.UnmuteCall, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+            plantronicsService.getCallEvents();
+            const deviceUnmuted = (0, test_utils_1.eventValidation)(plantronicsService, 'deviceMuteChanged');
+            yield deviceUnmuted;
+        }));
+        it('should hold from the headset', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/CallServices/CallEvents')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallEvents.HoldCall, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+            plantronicsService.getCallEvents();
+            const deviceHeld = (0, test_utils_1.eventValidation)(plantronicsService, 'deviceHoldStatusChanged');
+            yield deviceHeld;
+        }));
+        it('should resume from the headset', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/CallServices/CallEvents')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallEvents.ResumeCall, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+            plantronicsService.getCallEvents();
+            const deviceResumed = (0, test_utils_1.eventValidation)(plantronicsService, 'deviceHoldStatusChanged');
+            yield deviceResumed;
+        }));
+        it('should terminate the call from the headset', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/CallServices/CallEvents')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallEvents.TerminateCall, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+            plantronicsService.getCallEvents();
+            const deviceTerminated = (0, test_utils_1.eventValidation)(plantronicsService, 'deviceEndedCall');
+            yield deviceTerminated;
+        }));
+        it('should log an error if something goes wrong during _makeRequestTask', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/CallServices/IncomingCall')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.IncomingCall.default, true);
+                }
+                if (url.includes('/CallServices/CallEvents')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallEvents.TerminateCall, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.errorState, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            plantronicsService.isConnected = true;
+            plantronicsService.isActive = true;
+            plantronics_1.default['instance'] = null;
+            const loggerInfoSpy = jest.spyOn(plantronicsService.logger, 'info');
+            yield plantronicsService.getCallEvents();
+            expect(loggerInfoSpy).toHaveBeenCalledWith('Error making request for call events', expect.any(Error));
+        }));
+        it('should log a message if an unexpected event is received', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isActive = true;
+            plantronicsService.isConnected = true;
+            const loggerInfoSpy = jest.spyOn(plantronicsService.logger, 'info');
+            jest.spyOn(plantronicsService, '_makeRequestTask').mockResolvedValueOnce(plantronics_test_responses_1.default.CallServices.CallManagerState.unknownEvent);
+            yield plantronicsService.getCallEvents();
+            expect(loggerInfoSpy).toHaveBeenCalledWith('Unknown call event from headset', { event: plantronics_test_responses_1.default.CallServices.CallManagerState.unknownEvent.Result[0] });
+        }));
+    });
+    describe('connect function', () => {
+        it('handles all scenarios appropriately for Register endpoint', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/Register')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.Register.errorState, true);
+                }
+            });
+            return expect(plantronicsService.connect()).rejects.toEqual(plantronics_test_responses_1.default.SessionManager.Register.errorState);
+        }));
+        it('handles all scenarios appropriately for isActive endpoint', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.logger.debug = jest.fn();
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/Register')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.Register.default, true);
+                }
+                if (url.includes('/SessionManager/IsActive')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.IsActive.errorState, true);
+                }
+            });
+            try {
+                yield plantronicsService.connect();
+            }
+            catch (err) {
+                expect(plantronicsService.logger.debug).toHaveBeenCalledWith('Is Active', plantronics_test_responses_1.default.SessionManager.IsActive.errorState);
+            }
+        }));
+        it('handles all scenarios appropriately for getActiveCalls endpoint', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.logger.info = jest.fn();
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/Register')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.Register.default, true);
+                }
+                if (url.includes('/SessionManager/IsActive')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.IsActive.default, true);
+                }
+                if (url.includes('/UserPreference/SetDefaultSoftphone')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.UserPreference.SetDefaultSoftPhone.default, true);
+                }
+                if (url.includes('/DeviceServices/Info')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.DeviceServices.Info.default, true);
+                }
+                if (url.includes('/CallServices/CallManagerState')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.CallServices.CallManagerState.callsInProgress, true);
+                }
+                return buildMockFetch({}, true);
+            });
+            yield plantronicsService.connect();
+            expect(plantronicsService.isActive).toBe(true);
+            expect(plantronicsService.logger.info).toHaveBeenCalledWith('Currently active calls in the session');
+        }));
+        it('logs an error message if we are unable to connect the headset', () => __awaiter(void 0, void 0, void 0, function* () {
+            const errorLoggerSpy = jest.spyOn(plantronicsService.logger, 'error');
+            const testIsActiveEvent = {
+                Description: 'Is Active',
+                Result: true,
+                Type: 2,
+                Type_Name: 'Bool',
+                isError: false
+            };
+            jest.spyOn(plantronicsService, '_makeRequestTask')
+                .mockResolvedValueOnce(plantronics_test_responses_1.default.SessionManager.Register.default)
+                .mockResolvedValueOnce(testIsActiveEvent)
+                .mockRejectedValueOnce({ handled: true });
+            yield plantronicsService.connect();
+            expect(errorLoggerSpy).toHaveBeenCalledWith('Unable to properly connect headset');
+        }));
+        it('returns empty array if makeRequestTask resolves to undefined', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(plantronicsService, '_makeRequestTask').mockResolvedValueOnce(undefined);
+            const getActiveCallsResult = yield plantronicsService._getActiveCalls();
+            expect(getActiveCallsResult).toStrictEqual([]);
+        }));
+    });
+    describe('_makeRequest function', () => {
+        beforeEach(() => {
+            Object.defineProperty(browserama_1.default, 'isFirefox', { get: () => true });
+        });
+        it('handles error from endpoint with 404 status and isRetry', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isConnected = true;
+            plantronicsService.isActive = true;
+            const disconnectSpy = jest.spyOn(plantronicsService, 'disconnect');
+            plantronicsService.logger.info = jest.fn();
+            const isActiveResponseWithStatus = Object.assign(Object.assign({}, plantronics_test_responses_1.default.SessionManager.IsActive.default), { status: 404, 'Type_Name': 'Error' });
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/IsActive')) {
+                    return buildMockFetch(isActiveResponseWithStatus, true);
+                }
+            });
+            try {
+                yield plantronicsService._makeRequest(`/SessionManager/IsActive?name=${plantronicsService.pluginName}&active=true`, true);
+            }
+            catch (err) {
+                expect(plantronicsService.isConnected).toBe(false);
+                expect(disconnectSpy).toHaveBeenCalled();
+                expect(plantronicsService.logger.info).toHaveBeenCalledWith(err);
+            }
+        }));
+        it('handles error from endpoint with 404 status and !isRetry', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isConnected = true;
+            plantronicsService.isActive = true;
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
+            const isActiveResponseWithStatus = Object.assign(Object.assign({}, plantronics_test_responses_1.default.SessionManager.IsActive.default), { status: 404, 'Type_Name': 'Error' });
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/IsActive')) {
+                    return buildMockFetch(isActiveResponseWithStatus, true);
+                }
+            });
+            try {
+                yield plantronicsService._makeRequestTask(`/SessionManager/IsActive?name=${plantronicsService.pluginName}&active=true`);
+            }
+            catch (err) {
+                expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/SessionManager/IsActive?name=${plantronicsService.pluginName}&active=true`, true);
+            }
+        }));
+        it('handles browersama.isFirefox true error case', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isConnected = true;
+            plantronicsService.isActive = true;
+            const isActiveResponseWithStatus = Object.assign(Object.assign({}, plantronics_test_responses_1.default.SessionManager.IsActive.default), { status: 418, 'Type_Name': 'Error' });
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/IsActive')) {
+                    return buildMockFetch(isActiveResponseWithStatus, true);
+                }
+            });
+            try {
+                yield plantronicsService._makeRequest(`/SessionManager/IsActive?name=${plantronicsService.pluginName}&active=true`, false);
+            }
+            catch (err) {
+                expect(plantronicsService.errorCode).toBe('browser');
+                expect(plantronicsService.disableRetry).toBe(true);
+            }
+        }));
+        it('handles successful return but no plantronics instance', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isConnected = true;
+            plantronicsService.isActive = true;
+            plantronics_1.default['instance'] = null;
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/IsActive')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.IsActive.default, true);
+                }
+            });
+            const noInstanceError = new Error('Application destroyed.');
+            try {
+                yield plantronicsService._makeRequest(`/SessionManager/IsActive?name=${plantronicsService.pluginName}&active=true`, false);
+            }
+            catch (err) {
+                expect(err).toStrictEqual(noInstanceError);
+            }
+        }));
+    });
+    describe('disconnect function', () => {
+        it('calls makeRequestTask if the implementation is connected', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isConnected = true;
+            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask').mockResolvedValue(null);
+            yield plantronicsService.disconnect();
+            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/SessionManager/UnRegister?name=${plantronicsService.pluginName}`);
+        }));
+        it('sets the flags to the proper values after promise resolution', () => __awaiter(void 0, void 0, void 0, function* () {
+            plantronicsService.isConnected = true;
+            const clearTimeoutsSpy = jest.spyOn(plantronicsService, 'clearTimeouts');
+            jest.spyOn(plantronicsService, '_fetch').mockImplementation((url) => {
+                if (url.includes('/SessionManager/UnRegister')) {
+                    return buildMockFetch(plantronics_test_responses_1.default.SessionManager.UnRegister.default, true);
+                }
+            });
+            yield plantronicsService.disconnect();
+            expect(plantronicsService.isConnected).toBe(false);
+            expect(plantronicsService._deviceInfo).toBeNull();
+            expect(clearTimeoutsSpy).toHaveBeenCalled();
+            expect(plantronicsService.isActive).toBe(false);
+        }));
+    });
+    describe('_fetch', () => {
+        it('should call the fetchJsonp function with the proper URL', () => {
+            plantronicsService._fetch = originalFetchFunction;
+            console.log(plantronicsService._fetch('/test'));
+            plantronicsService._fetch('/test');
+            expect(fetch_jsonp_1.default).toHaveBeenCalledWith('/test');
+        });
+    });
+    describe('_createCallMapping', () => {
+        it('should populate the callMappings value in the service', () => {
+            const returnedValue = plantronicsService['_createCallMapping']('convoId123');
+            expect(plantronicsService.callMappings).toStrictEqual({
+                [returnedValue]: 'convoId123',
+                'convoId123': returnedValue
+            });
+        });
+    });
+});
+//# sourceMappingURL=plantronics.test.js.map