softphone-vendor-headsets 2.4.3 → 2.4.5-develop.42

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

@@ -0,0 +1,679 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vbet_1 = __importDefault(require("./vbet"));
+const mockTestDevName = 'Test VBet Dev';
+const mockDeviceList0 = [];
+const mockDeviceList1 = [
+    {
+        open: jest.fn(),
+        close: jest.fn(),
+        sendReport: jest.fn(),
+        addEventListener: jest.fn((name, callback) => {
+            callback({
+                reportId: 0x08,
+                data: {
+                    getUint8: jest.fn(),
+                },
+            });
+        }),
+        productName: mockTestDevName,
+        productId: 0x0001,
+        collections: [
+            {
+                usage: 0x0005,
+                usagePage: 0x000b,
+                inputReports: [
+                    {
+                        reportId: 0x08,
+                    },
+                ],
+            },
+        ],
+    },
+];
+const mockDeviceList2 = [
+    {
+        open: jest.fn(),
+        close: jest.fn(),
+        addEventListener: jest.fn((name, callback) => {
+            callback({
+                reportId: 0x01,
+                data: {
+                    getUint8: jest.fn(),
+                },
+            });
+        }),
+        productName: mockTestDevName,
+        collections: [
+            {
+                usage: 0,
+                usagePage: 0,
+            },
+        ],
+    },
+];
+const mockDeviceList3 = [
+    {
+        open: jest.fn(),
+        close: jest.fn(),
+        addEventListener: jest.fn((name, callback) => {
+            callback({
+                reportId: 0x01,
+                data: {
+                    getUint8: jest.fn(),
+                },
+            });
+        }),
+        productName: mockTestDevName,
+        collections: [
+            {
+                usage: 0x0005,
+                usagePage: 0x000b,
+                inputReports: [],
+            },
+        ],
+    },
+];
+const mockDeviceList5 = [
+    {
+        open: jest.fn(),
+        close: jest.fn(),
+        sendReport: jest.fn(),
+        addEventListener: jest.fn((name, callback) => {
+            callback({
+                reportId: 0x01,
+                data: {
+                    getUint8: jest.fn(),
+                },
+            });
+        }),
+        productName: mockTestDevName,
+        productId: 0x0020,
+        collections: [
+            {
+                usage: 0x0005,
+                usagePage: 0x000b,
+                inputReports: [
+                    {
+                        reportId: 0x01,
+                    },
+                ],
+            },
+        ],
+    },
+];
+const mockDeviceList6 = [
+    {
+        open: jest.fn(),
+        close: jest.fn(),
+        sendReport: jest.fn(),
+        addEventListener: jest.fn((name, callback) => {
+            callback({
+                reportId: 0x01,
+                data: {
+                    getUint8: jest.fn(),
+                },
+            });
+        }),
+        productName: mockTestDevName,
+        productId: 0x0014,
+        collections: [
+            {
+                usage: 0x0005,
+                usagePage: 0x000b,
+                inputReports: [
+                    {
+                        reportId: 0x01,
+                    },
+                ],
+            },
+        ],
+    },
+];
+const mockDeviceList7 = [
+    {
+        open: jest.fn(),
+        close: jest.fn(),
+        sendReport: jest.fn(),
+        addEventListener: jest.fn((name, callback) => {
+            callback({
+                reportId: 0x05,
+                data: {
+                    getUint8: jest.fn(),
+                },
+            });
+        }),
+        productName: mockTestDevName,
+        productId: 0x0040,
+        collections: [
+            {
+                usage: 0x0005,
+                usagePage: 0x000b,
+                inputReports: [
+                    {
+                        reportId: 0x05,
+                    },
+                ],
+            },
+        ],
+    },
+];
+const mockOffhookFlag = {
+    BT100USeries: 0x04,
+    CMEDIASeries: 0x01,
+    DECTSeries: 0x02,
+    ACTIONSeries: 0x20,
+};
+const mockOnhookFlag = {
+    BT100USeries: 0x00,
+    CMEDIASeries: 0x00,
+    DECTSeries: 0x00,
+    ACTIONSeries: 0x00,
+};
+const mockMuteFlag = {
+    BT100USeries: 0x0c,
+    CMEDIASeries: 0x14,
+    DECTSeries: [0x03, 0x04],
+    ACTIONSeries: [0x05, 0x01],
+};
+const mockReject = { BT100USeries: 0x10, ACTIONSeries: 0x08 };
+describe('VBetservice', () => {
+    let vbetService;
+    let mockDeviceList = mockDeviceList0;
+    let mockReqDeviceList = mockDeviceList0;
+    Object.defineProperty(window.navigator, 'hid', {
+        get: () => ({
+            getDevices: () => {
+                return mockDeviceList;
+            },
+            requestDevice: () => {
+                mockDeviceList = mockReqDeviceList;
+            },
+        }),
+    });
+    beforeEach(() => {
+        mockDeviceList = mockDeviceList0;
+        mockReqDeviceList = mockDeviceList0;
+        vbetService = vbet_1.default.getInstance({ logger: console });
+    });
+    afterEach(() => {
+        vbetService = null;
+        jest.restoreAllMocks();
+    });
+    describe('instantiation', () => {
+        it('should be a singleton', () => {
+            const vbetService2 = vbet_1.default.getInstance({ logger: console });
+            expect(vbetService).not.toBeFalsy();
+            expect(vbetService2).not.toBeFalsy();
+            expect(vbetService).toBe(vbetService2);
+        });
+        it('should have the correct vendorName', () => {
+            expect(vbetService.vendorName).toEqual('VBet');
+        });
+    });
+    describe('isSupported', () => {
+        it('should return true if proper values are met', () => {
+            expect(vbetService.isSupported()).toBe(true);
+        });
+        it('should return false if proper values are not met', () => {
+            Object.defineProperty(window, '_HostedContextFunctions', { get: () => true });
+            expect(vbetService.isSupported()).toBe(false);
+        });
+    });
+    describe('deviceLabelMatchesVendor', () => {
+        it('deviceLabelMatchesVendor', () => {
+            let result;
+            result = vbetService.deviceLabelMatchesVendor('Test vt Label');
+            expect(result).toBe(true);
+            result = vbetService.deviceLabelMatchesVendor('Something test');
+            expect(result).toBe(false);
+        });
+    });
+    describe('connect', () => {
+        afterEach(() => {
+            vbetService.disconnect();
+        });
+        it('should connect with previouslyConnectedDevice', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            mockDeviceList = mockDeviceList1;
+            yield vbetService.connect(mockTestDevName);
+            const devName = vbetService.deviceInfo;
+            expect(devName.ProductName).toBe(mockTestDevName);
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: true, isConnecting: false });
+        }));
+        it('already have active device', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            mockDeviceList = mockDeviceList1;
+            yield vbetService.connect(mockTestDevName);
+            yield vbetService.connect(mockTestDevName);
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: true, isConnecting: false });
+        }));
+        it('device usage not match', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                mockReqDeviceList = mockDeviceList0;
+                callback();
+            });
+            mockDeviceList = mockDeviceList2;
+            yield vbetService.connect(mockTestDevName);
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: false, isConnecting: false });
+        }));
+        it('device inputReports is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                mockReqDeviceList = mockDeviceList0;
+                callback();
+            });
+            mockDeviceList = mockDeviceList3;
+            yield vbetService.connect(mockTestDevName);
+            expect(vbetService.isConnected).toBe(true);
+            expect(vbetService.isConnecting).toBe(false);
+        }));
+        it('previouslyConnectedDevice not have device', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                mockReqDeviceList = mockDeviceList0;
+                callback();
+            });
+            mockDeviceList = mockDeviceList1;
+            yield vbetService.connect('test');
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: false, isConnecting: false });
+        }));
+        it('webhidRequest, 30s timeout, failed to connect', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            jest.useFakeTimers();
+            const requestSpy = (vbetService.requestWebHidPermissions = jest.fn(() => {
+                jest.advanceTimersByTime(30100);
+            }));
+            yield vbetService.connect(mockTestDevName);
+            expect(requestSpy).toHaveBeenCalled();
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: false, isConnecting: true });
+            jest.clearAllTimers();
+            jest.useRealTimers();
+        }));
+        it('webhidRequest, connect success', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            const requestSpy = (vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                mockReqDeviceList = mockDeviceList1;
+                callback();
+            }));
+            yield vbetService.connect(mockTestDevName);
+            expect(requestSpy).toHaveBeenCalled();
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: true, isConnecting: false });
+        }));
+        it('webhidRequest, connect fail', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            const requestSpy = (vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                callback();
+            }));
+            yield vbetService.connect(mockTestDevName);
+            expect(requestSpy).toHaveBeenCalled();
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: false, isConnecting: false });
+        }));
+        it('webhidRequest, connect fail, device name error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            const requestSpy = (vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                mockReqDeviceList = mockDeviceList1;
+                callback();
+            }));
+            yield vbetService.connect('test');
+            expect(requestSpy).toHaveBeenCalled();
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: false, isConnecting: false });
+        }));
+        it('webhidRequest, connect fail, device usage error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusChangeSpy = jest.spyOn(vbetService, 'changeConnectionStatus');
+            const requestSpy = (vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                mockReqDeviceList = mockDeviceList2;
+                callback();
+            }));
+            yield vbetService.connect(mockTestDevName);
+            expect(requestSpy).toHaveBeenCalled();
+            expect(statusChangeSpy).toHaveBeenCalledWith({ isConnected: false, isConnecting: false });
+        }));
+        it('webhidRequest, device inputReports is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            vbetService.requestWebHidPermissions = jest.fn((callback) => {
+                mockReqDeviceList = mockDeviceList3;
+                callback();
+            });
+            yield vbetService.connect(mockTestDevName);
+            expect(vbetService.isConnected).toBe(true);
+            expect(vbetService.isConnecting).toBe(false);
+        }));
+    });
+    describe('disconnect', () => {
+        it('test disconnect', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockDeviceList = mockDeviceList1;
+            vbetService.isConnecting = true;
+            yield vbetService.connect(mockTestDevName);
+            yield vbetService.disconnect();
+            expect(vbetService.isConnecting).toBe(false);
+            expect(vbetService.isConnected).toBe(false);
+        }));
+    });
+    describe('processBtnPress BT100USeries', () => {
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            mockDeviceList = mockDeviceList1;
+            yield vbetService.connect(mockTestDevName);
+        }));
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.endAllCalls();
+            yield vbetService.disconnect();
+        }));
+        it('activeDevice is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            yield vbetService.disconnect();
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            expect(ansFun).not.toHaveBeenCalled();
+        }));
+        it('test offhook', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceAnsweredCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+        it('test offhook but no active conversion id', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'sendOpToDevice');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceAnsweredCall');
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            expect(ansFun).not.toHaveBeenCalledWith('offHook');
+            expect(devAnsFun).not.toHaveBeenCalled();
+        }));
+        it('test onhook', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'endCallFromDevice');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceEndedCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            yield vbetService.processBtnPress(mockOnhookFlag.BT100USeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+        it('test onhook but no active conversion id', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'sendOpToDevice');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceEndedCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            vbetService.activeConversationId = null;
+            yield vbetService.processBtnPress(mockOnhookFlag.BT100USeries);
+            expect(ansFun).not.toHaveBeenCalledWith('onHook');
+            expect(devAnsFun).not.toHaveBeenCalled();
+        }));
+        it('test mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            yield vbetService.processBtnPress(mockMuteFlag.BT100USeries);
+            expect(setMuteFun).toHaveBeenCalledWith(true);
+            expect(devMuteFun).toHaveBeenCalledWith({
+                isMuted: true,
+                name: 'CallMuted',
+                conversationId: 'id',
+            });
+        }));
+        it('test unmute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            yield vbetService.processBtnPress(mockMuteFlag.BT100USeries);
+            yield vbetService.processBtnPress(mockMuteFlag.BT100USeries);
+            expect(setMuteFun).toHaveBeenCalledTimes(2);
+            expect(devMuteFun).toHaveBeenCalledTimes(2);
+        }));
+        it('test rejectCall', () => __awaiter(void 0, void 0, void 0, function* () {
+            const devRejectFun = jest.spyOn(vbetService, 'deviceRejectedCall');
+            const setRejectFun = jest.spyOn(vbetService, 'rejectCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockReject.BT100USeries);
+            expect(devRejectFun).toHaveBeenCalledWith({ name: 'Reject', conversationId: 'id' });
+            expect(setRejectFun).toHaveBeenCalled();
+        }));
+        it('test outgoing call', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'endCallFromDevice');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceEndedCall');
+            yield vbetService.outgoingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOnhookFlag.BT100USeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+        it('test auto answer call', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'sendOpToDevice');
+            yield vbetService.answerCall('id', true);
+            expect(ansFun).toHaveBeenCalledWith('ring');
+            expect(ansFun).toHaveBeenCalledWith('offHook');
+        }));
+    });
+    describe('processBtnPress CMEDIASeries', () => {
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            mockDeviceList = mockDeviceList5;
+            yield vbetService.connect(mockTestDevName);
+        }));
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.endAllCalls();
+            yield vbetService.disconnect();
+        }));
+        it('activeDevice is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.disconnect();
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            yield vbetService.processBtnPress(mockOffhookFlag.CMEDIASeries);
+            expect(ansFun).not.toHaveBeenCalled();
+        }));
+        it('test offhook', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceAnsweredCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.CMEDIASeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+        it('test mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.CMEDIASeries);
+            yield vbetService.processBtnPress(mockMuteFlag.CMEDIASeries);
+            expect(setMuteFun).toHaveBeenCalledWith(true);
+            expect(devMuteFun).toHaveBeenCalledWith({
+                isMuted: true,
+                name: 'CallMuted',
+                conversationId: 'id',
+            });
+        }));
+        it('test mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.CMEDIASeries);
+            yield vbetService.processBtnPress(0x08);
+            yield vbetService.processBtnPress(0x00);
+            expect(setMuteFun).toHaveBeenCalledWith(true);
+            expect(devMuteFun).toHaveBeenCalledWith({
+                isMuted: true,
+                name: 'CallMuted',
+                conversationId: 'id',
+            });
+        }));
+        it('test outgoing call', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'endCallFromDevice');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceEndedCall');
+            yield vbetService.outgoingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOnhookFlag.CMEDIASeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+    });
+    describe('processBtnPress DECTSeries', () => {
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            mockDeviceList = mockDeviceList6;
+            yield vbetService.connect(mockTestDevName);
+        }));
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.endAllCalls();
+            yield vbetService.disconnect();
+        }));
+        it('activeDevice is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.disconnect();
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            yield vbetService.processBtnPress(mockOffhookFlag.DECTSeries);
+            expect(ansFun).not.toHaveBeenCalled();
+        }));
+        it('test offhook', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceAnsweredCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.DECTSeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+        it('test mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.DECTSeries);
+            yield vbetService.processBtnPress(mockMuteFlag.DECTSeries[0]);
+            expect(setMuteFun).toHaveBeenCalledWith(true);
+            expect(devMuteFun).toHaveBeenCalledWith({
+                isMuted: true,
+                name: 'CallMuted',
+                conversationId: 'id',
+            });
+        }));
+        it('test unmute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.DECTSeries);
+            yield vbetService.processBtnPress(mockMuteFlag.DECTSeries[1]);
+            expect(setMuteFun).toHaveBeenCalledWith(false);
+            expect(devMuteFun).toHaveBeenCalledWith({
+                isMuted: false,
+                name: 'CallUnmuted',
+                conversationId: 'id',
+            });
+        }));
+        it('test outgoing call', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'endCallFromDevice');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceEndedCall');
+            yield vbetService.outgoingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOnhookFlag.DECTSeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+    });
+    describe('processBtnPress ACTIONSeries', () => {
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            mockDeviceList = mockDeviceList7;
+            yield vbetService.connect(mockTestDevName);
+        }));
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.endAllCalls();
+            yield vbetService.disconnect();
+        }));
+        it('activeDevice is null', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.disconnect();
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            yield vbetService.processBtnPress(mockOffhookFlag.ACTIONSeries);
+            expect(ansFun).not.toHaveBeenCalled();
+        }));
+        it('test offhook', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'answerCall');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceAnsweredCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.ACTIONSeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+        it('test reject', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'rejectCall');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceRejectedCall');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockReject.ACTIONSeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+        it('test mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.ACTIONSeries);
+            yield vbetService.processBtnPress(mockMuteFlag.ACTIONSeries[0]);
+            expect(setMuteFun).toHaveBeenCalledWith(true);
+            expect(devMuteFun).toHaveBeenCalledWith({
+                isMuted: true,
+                name: 'CallMuted',
+                conversationId: 'id',
+            });
+        }));
+        it('test unmute', () => __awaiter(void 0, void 0, void 0, function* () {
+            const setMuteFun = jest.spyOn(vbetService, 'setMute');
+            const devMuteFun = jest.spyOn(vbetService, 'deviceMuteChanged');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.ACTIONSeries);
+            yield vbetService.processBtnPress(mockMuteFlag.ACTIONSeries[1]);
+            expect(setMuteFun).toHaveBeenCalledWith(false);
+            expect(devMuteFun).toHaveBeenCalledWith({
+                isMuted: false,
+                name: 'CallUnmuted',
+                conversationId: 'id',
+            });
+        }));
+        it('test outgoing call', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'endCallFromDevice');
+            const devAnsFun = jest.spyOn(vbetService, 'deviceEndedCall');
+            yield vbetService.outgoingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOnhookFlag.ACTIONSeries);
+            expect(ansFun).toHaveBeenCalled();
+            expect(devAnsFun).toHaveBeenCalled();
+        }));
+    });
+    describe('endcall from user interface', () => {
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            mockDeviceList = mockDeviceList1;
+            yield vbetService.connect(mockTestDevName);
+        }));
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield vbetService.disconnect();
+        }));
+        it('test onhook', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'sendOpToDevice');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            yield vbetService.endCall('id', false);
+            expect(ansFun).toHaveBeenCalledWith('onHook');
+        }));
+        it('test onhook with other active calls', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'sendOpToDevice');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            yield vbetService.endCall('id', true);
+            expect(ansFun).not.toHaveBeenCalledWith('onHook');
+        }));
+        it('test onhook but no matching conversion id', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'sendOpToDevice');
+            yield vbetService.incomingCall({ conversationId: 'id' });
+            yield vbetService.processBtnPress(mockOffhookFlag.BT100USeries);
+            yield vbetService.endCall('dif', false);
+            expect(ansFun).not.toHaveBeenCalledWith('onHook');
+        }));
+        it('test reject call but no pending conversion id', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ansFun = jest.spyOn(vbetService, 'sendOpToDevice');
+            yield vbetService.incomingCall({ conversationId: '' });
+            yield vbetService.rejectCall();
+            expect(ansFun).not.toHaveBeenCalledWith('onHook');
+        }));
+    });
+});
+//# sourceMappingURL=vbet.test.js.map