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

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

@@ -1,796 +0,0 @@
-"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_test_1 = require("../../../test-utils.test");
-const plantronics_1 = __importDefault(require("./plantronics"));
-const plantronics_call_events_1 = require("./plantronics-call-events");
-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;
-}
-const sendScenario = function (scenario) {
-    return fetch(`${mockPlantronicsHost}/scenario`, {
-        method: 'post',
-        headers: {
-            "Content-Type": "application/json"
-        },
-        body: JSON.stringify(scenario),
-        mode: 'cors'
-    });
-};
-const queueCallEvents = function (scenario) {
-    return fetch(`${mockPlantronicsHost}/callEvents`, {
-        method: 'PUT',
-        headers: {
-            "Content-Type": "application/json"
-        },
-        body: JSON.stringify(scenario),
-        mode: 'cors'
-    });
-};
-let callbackCount = 1;
-describe('PlantronicsService', () => {
-    let plantronicsService;
-    beforeEach(() => {
-        plantronicsService = plantronics_1.default.getInstance({ logger: console });
-        plantronicsService._fetch = (url) => {
-            const fullUrl = `${url}&callback=${callbackCount++}`;
-            return fetch(fullUrl, {
-                method: 'get',
-                headers: {
-                    "Content-Type": "application/json"
-                }
-            });
-        };
-        resetService(plantronicsService);
-    });
-    afterAll(() => {
-        resetService(plantronicsService);
-    });
-    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('apiHost', () => {
-        it('should return the expected value', () => {
-            expect(plantronicsService.apiHost).toEqual(mockPlantronicsHost);
-        });
-    });
-    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_test_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();
-        });
-        it('will not call getCallEventsSpy if proper flags are not met', () => {
-            const getCallEventsSpy = jest.spyOn(plantronicsService, 'getCallEvents');
-            const pollForCallEventsSpy = jest.spyOn(plantronicsService, 'pollForCallEvents');
-            jest.useFakeTimers();
-            plantronicsService.pollForCallEvents();
-            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');
-            const pollForCallEventsSpy = jest.spyOn(plantronicsService, 'pollForCallEvents');
-            plantronicsService.isConnected = true;
-            plantronicsService.isActive = true;
-            plantronicsService.disableEventPolling = false;
-            jest.useFakeTimers();
-            plantronicsService.pollForCallEvents();
-            expect(getCallEventsSpy).toHaveBeenCalled();
-            jest.advanceTimersByTime(plantronicsService.activePollingInterval);
-            expect(pollForCallEventsSpy).toHaveBeenCalled();
-        });
-    });
-    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();
-        }));
-    });
-    describe('callCorrespondingFunction', () => {
-        it('will call deviceAnsweredCall', () => {
-            const deviceAnsweredCallSpy = jest.spyOn(plantronicsService, 'deviceAnsweredCall');
-            plantronicsService.callCorrespondingFunction({
-                name: 'AcceptCall',
-                code: '1',
-                event: {}
-            });
-            expect(deviceAnsweredCallSpy).toHaveBeenCalled();
-        });
-        it('will call deviceRejectedCall', () => {
-            plantronicsService.incomingConversationId = 'convoId1234';
-            const deviceRejectedCallSpy = jest.spyOn(plantronicsService, 'deviceRejectedCall');
-            plantronicsService.callCorrespondingFunction({
-                name: 'RejectCall',
-                code: '23',
-                event: {}
-            });
-            expect(deviceRejectedCallSpy).toHaveBeenCalledWith('convoId1234');
-        });
-        it('will call deviceEndedCall', () => {
-            const deviceEndedCallSpy = jest.spyOn(plantronicsService, 'deviceEndedCall');
-            plantronicsService.callCorrespondingFunction({
-                name: 'TerminateCall'
-            });
-            expect(deviceEndedCallSpy).toHaveBeenCalled();
-        });
-        it('will call _checkIsActiveTask', () => {
-            const _checkIsActiveTaskSpy = jest.spyOn(plantronicsService, '_checkIsActiveTask');
-            plantronicsService.callCorrespondingFunction({
-                name: 'CallEnded'
-            });
-            expect(_checkIsActiveTaskSpy).toHaveBeenCalled();
-        });
-        it('will call deviceMuteChanged with the proper flag', () => {
-            const deviceMuteChangedSpy = jest.spyOn(plantronicsService, 'deviceMuteChanged');
-            plantronicsService.callCorrespondingFunction({
-                name: 'Mute'
-            });
-            expect(deviceMuteChangedSpy).toHaveBeenCalledWith(true, { name: 'Mute' });
-            plantronicsService.callCorrespondingFunction({
-                name: 'Unmute'
-            });
-            expect(deviceMuteChangedSpy).toHaveBeenCalledWith(false, { name: 'Unmute' });
-        });
-        it('will call deviceHoldStatusChanged with the proper flag', () => {
-            const deviceHoldStatusChangedSpy = jest.spyOn(plantronicsService, 'deviceHoldStatusChanged');
-            plantronicsService.callCorrespondingFunction({
-                name: 'HoldCall'
-            });
-            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith(true, { name: 'HoldCall' });
-            plantronicsService.callCorrespondingFunction({
-                name: 'ResumeCall'
-            });
-            expect(deviceHoldStatusChangedSpy).toHaveBeenCalledWith(false, { name: 'ResumeCall' });
-        });
-        it('calls deviceEventLogs when no valid event was passed in', () => {
-            const deviceEventLogsSpy = jest.spyOn(plantronicsService, 'deviceEventLogs');
-            plantronicsService.callCorrespondingFunction({
-                name: 'Test'
-            });
-            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* () {
-            yield sendScenario({
-                '/SessionManager/Register*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.Register.default]
-                },
-                '/SessionManager/IsActive*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.IsActive.default]
-                },
-                '/UserPreference/SetDefaultSoftPhone*': {
-                    responses: [plantronics_test_responses_1.default.UserPreference.SetDefaultSoftPhone.default]
-                },
-                '/DeviceServices/Info*': {
-                    responses: [plantronics_test_responses_1.default.DeviceServices.Info.default]
-                },
-                '/CallServices/CallManagerState*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.CallManagerState.default]
-                }
-            });
-            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');
-            yield sendScenario({
-                '/CallServices/IncomingCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.IncomingCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            let callInfo = { conversationId: 'convoId123', contactName: 'Dio Brando' };
-            const conversationIdString = `"Id":"${callInfo.conversationId}"`;
-            const contactNameString = `"Name":"${callInfo.contactName}"`;
-            const endpointParams = `?name=${plantronicsService.pluginName}&tones=Unknown&route=ToHeadset`;
-            let completeEndpoint = endpointParams;
-            completeEndpoint += encodeURI(`&callID={${encodeURI(conversationIdString)}}`);
-            completeEndpoint += encodeURI(`&contact={${encodeURI(contactNameString)}}`);
-            yield plantronicsService.incomingCall(callInfo);
-            expect(plantronicsService.isActive).toBe(true);
-            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/CallServices/IncomingCall${completeEndpoint}`);
-            resetService(plantronicsService);
-            completeEndpoint = endpointParams;
-            completeEndpoint += encodeURI(`&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');
-            yield sendScenario({
-                '/CallServices/OutgoingCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.OutgoingCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            let callInfo = { conversationId: 'convoId123', contactName: 'Dio Brando' };
-            const conversationIdString = `"Id":"${callInfo.conversationId}"`;
-            const contactNameString = `"Name":"${callInfo.contactName}"`;
-            const endpointParams = `?name=${plantronicsService.pluginName}&tones=Unknown&route=ToHeadset`;
-            let completeEndpoint = endpointParams;
-            completeEndpoint += encodeURI(`&callID={${encodeURI(conversationIdString)}}`);
-            completeEndpoint += encodeURI(`&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 += encodeURI(`&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');
-            yield sendScenario({
-                '/CallServices/AnswerCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.AnswerCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            const conversationIdString = encodeURI(`"Id":"convoId123"`);
-            let completeEndpoint = `?name=${plantronicsService.pluginName}`;
-            completeEndpoint += encodeURI(`&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');
-            yield sendScenario({
-                '/CallServices/TerminateCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.TerminateCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            const conversationIdString = encodeURI(`"Id":"convoId123"`);
-            let completeEndpoint = `?name=${plantronicsService.pluginName}`;
-            completeEndpoint += encodeURI(`&callID={${conversationIdString}}`);
-            yield plantronicsService.endCall('convoId123');
-            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');
-            yield sendScenario({
-                '/CallServices/CallManagerState*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.CallManagerState.callsInProgress]
-                }
-            });
-            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('');
-            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');
-            yield sendScenario({
-                '/CallServices/MuteCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.MuteCall.mute, plantronics_test_responses_1.default.CallServices.MuteCall.unmute]
-                }
-            });
-            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');
-            yield sendScenario({
-                '/CallServices/HoldCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.HoldCall.default]
-                },
-                '/CallServices/ResumeCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.ResumeCall.default]
-                }
-            });
-            const conversationIdString = encodeURI(`"Id":"convoId123"`);
-            let completeEndpoint = `?name=${plantronicsService.pluginName}`;
-            completeEndpoint += encodeURI(`&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* () {
-            yield sendScenario({
-                '/CallServices/CallManagerState*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.CallManagerState.callsInProgress]
-                }
-            });
-            yield plantronicsService._checkIsActiveTask();
-            expect(plantronicsService.isActive).toBe(true);
-        }));
-        it('catches the error during _getActiveCalls', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield sendScenario({
-                '/CallServices/CallManagerState*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.CallManagerState.errorState]
-                }
-            });
-            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* () {
-            yield sendScenario({
-                '/DeviceServices/Info*': {
-                    responses: [plantronics_test_responses_1.default.DeviceServices.Info.errorState]
-                }
-            });
-            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('handles scenarios for getCallEvents function', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield sendScenario({
-                '/CallServices/IncomingCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.IncomingCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            plantronicsService.isActive = true;
-            plantronicsService.isConnected = true;
-            yield queueCallEvents([plantronics_call_events_1.PlantronicsCallEvents.AcceptCall, plantronics_call_events_1.PlantronicsCallEvents.CallInProgress]);
-        }));
-    });
-    describe('getCallEvents', () => {
-        it('should answer from headset', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield sendScenario({
-                '/CallServices/IncomingCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.IncomingCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            plantronicsService.isActive = true;
-            plantronicsService.isConnected = true;
-            const deviceAnswered = test_utils_test_1.eventValidation(plantronicsService, 'deviceAnsweredCall');
-            yield queueCallEvents([plantronics_call_events_1.PlantronicsCallEvents.AcceptCall, plantronics_call_events_1.PlantronicsCallEvents.CallInProgress]);
-            yield deviceAnswered;
-        }));
-        it('should mute and unmute from headset', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield sendScenario({
-                '/CallServices/IncomingCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.IncomingCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            plantronicsService.isActive = true;
-            plantronicsService.isConnected = true;
-            const deviceMuted = test_utils_test_1.eventValidation(plantronicsService, 'deviceMuteChanged');
-            yield queueCallEvents([plantronics_call_events_1.PlantronicsCallEvents.Mute]);
-            yield deviceMuted;
-            const deviceUnmuted = test_utils_test_1.eventValidation(plantronicsService, 'deviceMuteChanged');
-            yield queueCallEvents([plantronics_call_events_1.PlantronicsCallEvents.Unmute]);
-            yield deviceUnmuted;
-        }));
-        it('should hold and resume from the headset', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield sendScenario({
-                '/CallServices/IncomingCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.IncomingCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            plantronicsService.isActive = true;
-            plantronicsService.isConnected = true;
-            const deviceHeld = test_utils_test_1.eventValidation(plantronicsService, 'deviceHoldStatusChanged');
-            yield queueCallEvents([plantronics_call_events_1.PlantronicsCallEvents.HoldCall]);
-            yield deviceHeld;
-            const deviceResumed = test_utils_test_1.eventValidation(plantronicsService, 'deviceHoldStatusChanged');
-            yield queueCallEvents([plantronics_call_events_1.PlantronicsCallEvents.ResumeCall]);
-            yield deviceResumed;
-        }));
-        it('should terminate the call from the headset', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield sendScenario({
-                '/CallServices/IncomingCall*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.IncomingCall.default]
-                },
-                '/DeviceServices/Info*': {
-                    repeatResponse: plantronics_test_responses_1.default.DeviceServices.Info.default
-                }
-            });
-            plantronicsService.isActive = true;
-            plantronicsService.isConnected = true;
-            const deviceTerminated = test_utils_test_1.eventValidation(plantronicsService, 'deviceEndedCall');
-            yield queueCallEvents([plantronics_call_events_1.PlantronicsCallEvents.TerminateCall]);
-            yield deviceTerminated;
-        }));
-        it('should log an error if something goes wrong during _makeRequestTask', () => __awaiter(void 0, void 0, void 0, function* () {
-            plantronicsService.isConnected = true;
-            plantronicsService.isActive = true;
-            plantronics_1.default['instance'] = null;
-            const loggerInfoSpy = jest.spyOn(plantronicsService.logger, 'info');
-            try {
-                plantronicsService.getCallEvents();
-            }
-            catch (err) {
-                expect(loggerInfoSpy).toHaveBeenCalledWith('Error making request for all events', err);
-            }
-        }));
-        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* () {
-            yield sendScenario({
-                '/SessionManager/Register*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.Register.errorState]
-                }
-            });
-            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();
-            yield sendScenario({
-                '/SessionManager/Register*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.Register.default]
-                },
-                '/SessionManager/IsActive*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.IsActive.errorState]
-                }
-            });
-            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();
-            yield sendScenario({
-                '/SessionManager/Register*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.Register.default]
-                },
-                '/SessionManager/IsActive*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.IsActive.default]
-                },
-                '/UserPreference/SetDefaultSoftPhone*': {
-                    responses: [plantronics_test_responses_1.default.UserPreference.SetDefaultSoftPhone.default]
-                },
-                '/DeviceServices/Info*': {
-                    responses: [plantronics_test_responses_1.default.DeviceServices.Info.default]
-                },
-                '/CallServices/CallManagerState*': {
-                    responses: [plantronics_test_responses_1.default.CallServices.CallManagerState.callsInProgress]
-                }
-            });
-            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' });
-            yield sendScenario({
-                '/SessionManager/IsActive*': {
-                    responses: [isActiveResponseWithStatus]
-                }
-            });
-            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' });
-            yield sendScenario({
-                '/SessionManager/IsActive*': {
-                    responses: [isActiveResponseWithStatus]
-                }
-            });
-            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' });
-            yield sendScenario({
-                '/SessionManager/IsActive*': {
-                    responses: [isActiveResponseWithStatus]
-                }
-            });
-            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;
-            yield sendScenario({
-                '/SessionManager/IsActive*': {
-                    responses: [plantronics_test_responses_1.default.SessionManager.IsActive.default]
-                }
-            });
-            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', () => {
-            plantronicsService.isConnected = true;
-            const _makeRequestTaskSpy = jest.spyOn(plantronicsService, '_makeRequestTask');
-            plantronicsService.disconnect();
-            expect(_makeRequestTaskSpy).toHaveBeenCalledWith(`/SessionManager/UnRegister?name=${plantronicsService.pluginName}`);
-        });
-        it('sets the flags to the proper values after promise resolution', (done) => {
-            plantronicsService.isConnected = true;
-            const clearTimeoutsSpy = jest.spyOn(plantronicsService, 'clearTimeouts');
-            plantronicsService.disconnect().then(() => {
-                expect(plantronicsService.isConnected).toBe(false);
-                expect(plantronicsService._deviceInfo).toBeNull();
-                expect(clearTimeoutsSpy).toHaveBeenCalled();
-                expect(plantronicsService.isActive).toBe(false);
-                done();
-            });
-        });
-    });
-    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');
-        });
-    });
-});
-//# sourceMappingURL=plantronics.test.js.map