mirror of
https://github.com/pavlobu/deskreen.git
synced 2025-05-18 08:20:10 -07:00
474 lines
16 KiB
TypeScript
474 lines
16 KiB
TypeScript
/* eslint-disable @typescript-eslint/ban-ts-comment */
|
|
import { ipcRenderer } from 'electron';
|
|
import PeerConnection from '.';
|
|
import RoomIDService from '../../server/RoomIDService';
|
|
import ConnectedDevicesService from '../ConnectedDevicesService';
|
|
import SharingSessionService from '../SharingSessionService';
|
|
import DesktopCapturerSourcesService from '../DesktopCapturerSourcesService';
|
|
import {
|
|
TEST_APP_LANGUAGE,
|
|
TEST_APP_THEME,
|
|
TEST_ROOM_ID,
|
|
TEST_SHARING_SESSION_ID,
|
|
TEST_USER,
|
|
} from './mocks/testVars';
|
|
import setDisplaySizeFromLocalStream from './handleSetDisplaySizeFromLocalStream';
|
|
import handleSelfDestroy from './handleSelfDestroy';
|
|
import handleRecieveEncryptedMessage from './handleRecieveEncryptedMessage';
|
|
import handleCreatePeer from './handleCreatePeer';
|
|
import { prepare as prepareMessage } from '../../utils/message';
|
|
|
|
jest.useFakeTimers();
|
|
|
|
jest.mock('simple-peer');
|
|
const TEST_SOURCE_DISPLAY_SIZE = {
|
|
width: 640,
|
|
height: 480,
|
|
};
|
|
const TEST_DATA_TO_SEND_IN_ENCRYPTED_MESSAGE = 'oji23oi12p34';
|
|
jest.mock('electron', () => {
|
|
return {
|
|
ipcRenderer: {
|
|
invoke: jest.fn().mockImplementation(() => {
|
|
return TEST_SOURCE_DISPLAY_SIZE;
|
|
}),
|
|
},
|
|
};
|
|
});
|
|
jest.mock('./handleSetDisplaySizeFromLocalStream');
|
|
jest.mock('./handleSelfDestroy');
|
|
jest.mock('../../utils/message', () => {
|
|
return {
|
|
prepare: jest.fn().mockReturnValue({
|
|
toSend: TEST_DATA_TO_SEND_IN_ENCRYPTED_MESSAGE,
|
|
}),
|
|
};
|
|
});
|
|
jest.mock('./handleRecieveEncryptedMessage');
|
|
jest.mock('./handleCreatePeer');
|
|
|
|
const TEST_DISPLAY_ID = '21';
|
|
|
|
describe('PeerConnection index.ts tests', () => {
|
|
let peerConnection: PeerConnection;
|
|
const mockGetSourceDisplayIDBySourceID = jest.fn().mockImplementation(() => {
|
|
return TEST_DISPLAY_ID;
|
|
});
|
|
|
|
beforeEach(() => {
|
|
peerConnection = new PeerConnection(
|
|
TEST_ROOM_ID,
|
|
TEST_SHARING_SESSION_ID,
|
|
TEST_USER,
|
|
TEST_APP_THEME, // TODO getAppTheme
|
|
TEST_APP_LANGUAGE, // TODO getLanguage
|
|
{} as RoomIDService,
|
|
{} as ConnectedDevicesService,
|
|
{} as SharingSessionService,
|
|
({} as unknown) as DesktopCapturerSourcesService
|
|
);
|
|
peerConnection.displayID = 'screen:123idid';
|
|
});
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks();
|
|
jest.restoreAllMocks();
|
|
});
|
|
|
|
describe('when PeerConnection constructor was called', () => {
|
|
it('should be created with internal properties correclty', () => {
|
|
expect(peerConnection.roomIDService).toBeDefined();
|
|
expect(peerConnection.connectedDevicesService).toBeDefined();
|
|
expect(peerConnection.sharingSessionService).toBeDefined();
|
|
});
|
|
|
|
describe('when setAppLanguage was called', () => {
|
|
it('should set peerConnection app language and call notifyClientWithNewLanguage', () => {
|
|
const TEST_APP_LANG = 'ua';
|
|
const mockNotify = jest.fn();
|
|
peerConnection.notifyClientWithNewLanguage = mockNotify;
|
|
|
|
peerConnection.setAppLanguage(TEST_APP_LANG);
|
|
|
|
expect(mockNotify).toBeCalled();
|
|
expect(peerConnection.appLanguage).toBe(TEST_APP_LANG);
|
|
});
|
|
});
|
|
|
|
describe('when setAppTheme was called', () => {
|
|
it('should set peerConnection theme and call notifyClientWithNewColorTheme', () => {
|
|
const APP_THEME = true;
|
|
const mockNotify = jest.fn();
|
|
peerConnection.notifyClientWithNewColorTheme = mockNotify;
|
|
|
|
peerConnection.setAppTheme(APP_THEME);
|
|
|
|
expect(mockNotify).toBeCalled();
|
|
expect(peerConnection.appColorTheme).toBe(APP_THEME);
|
|
});
|
|
});
|
|
|
|
describe('when notifyClientWithNewLanguage was called', () => {
|
|
it('should call sendEncryptedMessage with proper payload', () => {
|
|
peerConnection.sendEncryptedMessage = jest.fn();
|
|
|
|
peerConnection.notifyClientWithNewLanguage();
|
|
|
|
expect(peerConnection.sendEncryptedMessage).toBeCalledWith({
|
|
type: 'APP_LANGUAGE',
|
|
payload: { value: peerConnection.appLanguage },
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when notifyClientWithNewColorTheme was called', () => {
|
|
it('should call sendEncryptedMessage with proper payload', () => {
|
|
peerConnection.sendEncryptedMessage = jest.fn();
|
|
|
|
peerConnection.notifyClientWithNewColorTheme();
|
|
|
|
expect(peerConnection.sendEncryptedMessage).toBeCalledWith({
|
|
type: 'APP_THEME',
|
|
payload: { value: peerConnection.appColorTheme },
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when setDesktopCapturerSourceID was called', () => {
|
|
it('should set .desktopCapturerSourceID and call other callbacks', () => {
|
|
const testSourceID = 'screen:asdfsffs1234';
|
|
process.env.RUN_MODE = 'dev';
|
|
peerConnection.setDisplayIDByDesktopCapturerSourceID = jest.fn();
|
|
peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet = jest.fn();
|
|
|
|
peerConnection.setDesktopCapturerSourceID(testSourceID);
|
|
|
|
process.env.RUN_MODE = 'test';
|
|
expect(peerConnection.desktopCapturerSourceID).toBe(testSourceID);
|
|
expect(
|
|
peerConnection.setDisplayIDByDesktopCapturerSourceID
|
|
).toBeCalled();
|
|
expect(
|
|
peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet
|
|
).toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when setDisplayIDByDesktopCapturerSourceID was called', () => {
|
|
describe('when desktopCapture source id is screen', () => {
|
|
it('should set .desktopCapturerSourceID and call other callbacks', () => {
|
|
peerConnection.desktopCapturerSourceID = 'screen:asdfa2';
|
|
peerConnection.setDisplaySizeRetreivedFromMainProcess = jest.fn();
|
|
peerConnection.desktopCapturerSourcesService = ({
|
|
getSourceDisplayIDBySourceID: mockGetSourceDisplayIDBySourceID,
|
|
} as unknown) as DesktopCapturerSourcesService;
|
|
|
|
peerConnection.setDisplayIDByDesktopCapturerSourceID();
|
|
|
|
expect(
|
|
peerConnection.setDisplaySizeRetreivedFromMainProcess
|
|
).toBeCalled();
|
|
expect(mockGetSourceDisplayIDBySourceID).toBeCalled();
|
|
expect(peerConnection.displayID).toBe(TEST_DISPLAY_ID);
|
|
});
|
|
});
|
|
|
|
describe('when desktopCapture source id is window', () => {
|
|
it('should not set anything', () => {
|
|
peerConnection.desktopCapturerSourceID = 'window:asdfa2';
|
|
peerConnection.setDisplaySizeRetreivedFromMainProcess = jest.fn();
|
|
peerConnection.desktopCapturerSourcesService = ({
|
|
getSourceDisplayIDBySourceID: mockGetSourceDisplayIDBySourceID,
|
|
} as unknown) as DesktopCapturerSourcesService;
|
|
|
|
peerConnection.setDisplayIDByDesktopCapturerSourceID();
|
|
|
|
expect(
|
|
peerConnection.setDisplaySizeRetreivedFromMainProcess
|
|
).not.toBeCalled();
|
|
expect(mockGetSourceDisplayIDBySourceID).not.toBeCalled();
|
|
expect(peerConnection.displayID).not.toBe(TEST_DISPLAY_ID);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when setDisplaySizeRetreivedFromMainProcess was called', () => {
|
|
it('should call .invoke on ipcRenderer with proper parameters', async () => {
|
|
await peerConnection.setDisplaySizeRetreivedFromMainProcess();
|
|
|
|
expect(ipcRenderer.invoke).toBeCalledWith(
|
|
'get-display-size-by-display-id',
|
|
peerConnection.displayID
|
|
);
|
|
expect(peerConnection.sourceDisplaySize).toBe(TEST_SOURCE_DISPLAY_SIZE);
|
|
});
|
|
|
|
describe('when .invoke returned "undefined"', () => {
|
|
it('should not set sourceDisplaySize', async () => {
|
|
// @ts-ignore
|
|
ipcRenderer.invoke.mockImplementation(() => {
|
|
return 'undefined';
|
|
});
|
|
|
|
await peerConnection.setDisplaySizeRetreivedFromMainProcess();
|
|
|
|
expect(ipcRenderer.invoke).toBeCalledWith(
|
|
'get-display-size-by-display-id',
|
|
peerConnection.displayID
|
|
);
|
|
expect(peerConnection.sourceDisplaySize).not.toBe(
|
|
TEST_SOURCE_DISPLAY_SIZE
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when handleCreatePeerAfterDesktopCapturerSourceIDWasSet was called', () => {
|
|
describe('when .sourceDisplaySize is defined', () => {
|
|
it('should call setDisplaySizeFromLocalStream', async () => {
|
|
peerConnection.createPeer = jest.fn();
|
|
peerConnection.sourceDisplaySize = TEST_SOURCE_DISPLAY_SIZE;
|
|
|
|
await peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet();
|
|
|
|
expect(peerConnection.createPeer).toBeCalled();
|
|
expect(setDisplaySizeFromLocalStream).not.toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when .sourceDisplaySize is NOT defined', () => {
|
|
it('should call setDisplaySizeFromLocalStream', async () => {
|
|
peerConnection.createPeer = jest.fn();
|
|
|
|
await peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet();
|
|
|
|
expect(peerConnection.createPeer).toBeCalled();
|
|
expect(setDisplaySizeFromLocalStream).toBeCalled();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when setOnDeviceConnectedCallback was called properly', () => {
|
|
it('should set onDeviceConnectedCallback', () => {
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const testCallback = (_: Device) => {};
|
|
peerConnection.setOnDeviceConnectedCallback(testCallback);
|
|
|
|
expect(peerConnection.onDeviceConnectedCallback).toBe(testCallback);
|
|
});
|
|
});
|
|
|
|
describe('when denyConnectionForPartner was called properly', () => {
|
|
it('should call sendEncryptedMessage with proper payload and call .disconnectPartner', async () => {
|
|
const testPayload = {
|
|
type: 'DENY_TO_CONNECT',
|
|
payload: {},
|
|
};
|
|
peerConnection.sendEncryptedMessage = jest.fn();
|
|
peerConnection.disconnectPartner = jest.fn();
|
|
|
|
await peerConnection.denyConnectionForPartner();
|
|
|
|
expect(peerConnection.sendEncryptedMessage).toBeCalledWith(testPayload);
|
|
expect(peerConnection.disconnectPartner).toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when sendUserAllowedToConnect was called properly', () => {
|
|
it('should call sendEncryptedMessage with proper payload', () => {
|
|
const testPayload = {
|
|
type: 'ALLOWED_TO_CONNECT',
|
|
payload: {},
|
|
};
|
|
peerConnection.sendEncryptedMessage = jest.fn();
|
|
|
|
peerConnection.sendUserAllowedToConnect();
|
|
|
|
expect(peerConnection.sendEncryptedMessage).toBeCalledWith(testPayload);
|
|
});
|
|
});
|
|
|
|
describe('when disconnectByHostMachineUser was called properly', () => {
|
|
it('should call sendEncryptedMessage with proper payload and call .disconnectPartner and .selfDestroy', async () => {
|
|
const testPayload = {
|
|
type: 'DISCONNECT_BY_HOST_MACHINE_USER',
|
|
payload: {},
|
|
};
|
|
peerConnection.sendEncryptedMessage = jest.fn();
|
|
peerConnection.disconnectPartner = jest.fn();
|
|
peerConnection.selfDestroy = jest.fn();
|
|
|
|
await peerConnection.disconnectByHostMachineUser();
|
|
|
|
expect(peerConnection.sendEncryptedMessage).toBeCalledWith(testPayload);
|
|
expect(peerConnection.disconnectPartner).toBeCalled();
|
|
expect(peerConnection.selfDestroy).toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when disconnectPartner was called properly', () => {
|
|
it('should call sendEncryptedMessage with proper payload', () => {
|
|
const testEmitData = {
|
|
ip: peerConnection.partnerDeviceDetails.deviceIP,
|
|
};
|
|
peerConnection.socket = ({
|
|
emit: jest.fn(),
|
|
} as unknown) as SocketIOClient.Socket;
|
|
|
|
peerConnection.disconnectPartner();
|
|
|
|
expect(peerConnection.socket.emit).toBeCalledWith(
|
|
'DISCONNECT_SOCKET_BY_DEVICE_IP',
|
|
testEmitData
|
|
);
|
|
expect(peerConnection.partnerDeviceDetails).toEqual({});
|
|
});
|
|
});
|
|
|
|
describe('when selfDestroy was called', () => {
|
|
it('should call handleSelfDestroy', () => {
|
|
peerConnection.selfDestroy();
|
|
|
|
expect(handleSelfDestroy).toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when emitUserEnter was called', () => {
|
|
describe('when .socket is defined', () => {
|
|
it('should call socket emit with proper parameters', () => {
|
|
const testEmitData = {
|
|
username: peerConnection.user.username,
|
|
publicKey: peerConnection.user.publicKey,
|
|
};
|
|
peerConnection.socket = ({
|
|
emit: jest.fn(),
|
|
} as unknown) as SocketIOClient.Socket;
|
|
|
|
peerConnection.emitUserEnter();
|
|
|
|
expect(peerConnection.socket.emit).toBeCalledWith(
|
|
'USER_ENTER',
|
|
testEmitData
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when sendEncryptedMessage was called', () => {
|
|
describe('when it was NOT called properly', () => {
|
|
it('should not call "prepare" from message.ts if socket is not defined', () => {
|
|
peerConnection.socket = (undefined as unknown) as SocketIOClient.Socket;
|
|
|
|
peerConnection.sendEncryptedMessage(
|
|
({} as unknown) as SendEncryptedMessagePayload
|
|
);
|
|
|
|
expect(prepareMessage).not.toBeCalled();
|
|
});
|
|
|
|
it('should not call "prepare" from message.ts if user is not defined', () => {
|
|
peerConnection.user = (undefined as unknown) as LocalPeerUser;
|
|
|
|
peerConnection.sendEncryptedMessage(
|
|
({} as unknown) as SendEncryptedMessagePayload
|
|
);
|
|
|
|
expect(prepareMessage).not.toBeCalled();
|
|
});
|
|
|
|
it('should not call "prepare" from message.ts if partner is not defined', () => {
|
|
peerConnection.partner = (undefined as unknown) as LocalPeerUser;
|
|
|
|
peerConnection.sendEncryptedMessage(
|
|
({} as unknown) as SendEncryptedMessagePayload
|
|
);
|
|
|
|
expect(prepareMessage).not.toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when it was called properly', () => {
|
|
it('should call "prepare" from message.ts and .socket.emit(ENCRYPTED_MESSAGE', async () => {
|
|
const testPayload = ({} as unknown) as SendEncryptedMessagePayload;
|
|
peerConnection.socket = ({
|
|
emit: jest.fn(),
|
|
} as unknown) as SocketIOClient.Socket;
|
|
peerConnection.partner = TEST_USER;
|
|
|
|
await peerConnection.sendEncryptedMessage(testPayload);
|
|
|
|
expect(prepareMessage).toBeCalledWith(
|
|
testPayload,
|
|
TEST_USER,
|
|
TEST_USER
|
|
);
|
|
expect(peerConnection.socket.emit).toBeCalledWith(
|
|
'ENCRYPTED_MESSAGE',
|
|
TEST_DATA_TO_SEND_IN_ENCRYPTED_MESSAGE
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when receiveEncryptedMessage was called', () => {
|
|
describe('when peerConnection user is NOT defined', () => {
|
|
it('should NOT call handleRecieveEncryptedMessage', () => {
|
|
const testPayload = {} as ReceiveEncryptedMessagePayload;
|
|
peerConnection.user = (undefined as unknown) as LocalPeerUser;
|
|
|
|
peerConnection.receiveEncryptedMessage(testPayload);
|
|
|
|
expect(handleRecieveEncryptedMessage).not.toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when peerConnection user is defined', () => {
|
|
it('should call handleRecieveEncryptedMessage', () => {
|
|
const testPayload = {} as ReceiveEncryptedMessagePayload;
|
|
|
|
peerConnection.receiveEncryptedMessage(testPayload);
|
|
|
|
expect(handleRecieveEncryptedMessage).toBeCalled();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when callPeer was called', () => {
|
|
describe('when it was called when call already started', () => {
|
|
it('should NOT call .sendEncryptedMessage', () => {
|
|
process.env.RUN_MODE = 'dev';
|
|
peerConnection.isCallStarted = true;
|
|
peerConnection.sendEncryptedMessage = jest.fn();
|
|
peerConnection.signalsDataToCallUser = ['asdfasdf'];
|
|
|
|
peerConnection.callPeer();
|
|
|
|
process.env.RUN_MODE = 'test';
|
|
expect(peerConnection.sendEncryptedMessage).not.toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('when it was called when call NOT started', () => {
|
|
it('should call .sendEncryptedMessage', () => {
|
|
process.env.RUN_MODE = 'dev';
|
|
peerConnection.sendEncryptedMessage = jest.fn();
|
|
peerConnection.signalsDataToCallUser = ['asdfasdf'];
|
|
|
|
peerConnection.callPeer();
|
|
|
|
process.env.RUN_MODE = 'test';
|
|
expect(peerConnection.sendEncryptedMessage).toBeCalled();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when createPeer was called', () => {
|
|
it('should call handleCreatePeer callback', () => {
|
|
peerConnection.createPeer();
|
|
|
|
expect(handleCreatePeer).toBeCalled();
|
|
});
|
|
});
|
|
});
|
|
});
|