// /* eslint-disable @typescript-eslint/ban-ts-comment */
// import uuid from 'uuid';
// import {
//   TEST_ROOM_ID,
//   TEST_SHARING_SESSION_ID,
//   TEST_USER,
// } from './mocks/testVars';
// import PeerConnection from '.';
// import RoomIDService from '../../server/RoomIDService';
// import ConnectedDevicesService from '../ConnectedDevicesService';
// import SharingSessionService from '../SharingSessionService';
// import { process as processMessage } from '../../utils/message';
// import NullSimplePeer from './NullSimplePeer';
// import handleRecieveEncryptedMessage, {
//   handleDeviceIPMessage,
// } from './handleRecieveEncryptedMessage';
// import DesktopCapturerSourcesService from '../DesktopCapturerSourcesService';
// import getAppTheme from '../../utils/getAppTheme';
// import getAppLanguage from '../../utils/getAppLanguage';

// jest.useFakeTimers();

// jest.mock('simple-peer');
// jest.mock('../../utils/message', () => {
//   return { process: jest.fn() };
// });
// jest.mock('uuid', () => {
//   return {
//     v4: () => '1234kdkd',
//   };
// });

// const TEST_DEVICE_DETAILS_PAYLOAD = {
//   socketID: '123',
//   deviceType: 'computer',
//   os: 'Windows',
//   browser: 'Chrome 72',
//   deviceScreenWidth: 640,
//   deviceScreenHeight: 480,
// };

// const TEST_DUMMY_ENCRYPTED_MESSAGE_PAYLOAD = ({
//   fromSocketID: '2411',
// } as unknown) as ReceiveEncryptedMessagePayload;

// describe('handleRecieveEncryptedMessage.ts', () => {
//   let peerConnection: PeerConnection;

//   beforeEach(() => {
//     peerConnection = new PeerConnection(
//       TEST_ROOM_ID,
//       TEST_SHARING_SESSION_ID,
//       TEST_USER,
//       {} as RoomIDService,
//       {} as ConnectedDevicesService,
//       {} as SharingSessionService,
//       {} as DesktopCapturerSourcesService
//     );
//   });

//   afterEach(() => {
//     jest.clearAllMocks();
//     jest.restoreAllMocks();
//   });

//   describe('when handleRecieveEncryptedMessage called properly', () => {
//     describe('when processed message type is CALL_ACCEPTED', () => {
//       it('should call peer.signal() with proper signal data', async () => {
//         const TEST_SIGNAL_DATA = 'a32sdlf';
//         // @ts-ignore
//         processMessage.mockImplementation(() => {
//           return {
//             type: 'CALL_ACCEPTED',
//             payload: {
//               signalData: TEST_SIGNAL_DATA,
//             },
//           };
//         });
//         peerConnection.peer = ({
//           signal: jest.fn(),
//         } as unknown) as typeof NullSimplePeer;

//         await handleRecieveEncryptedMessage(
//           peerConnection,
//           TEST_DUMMY_ENCRYPTED_MESSAGE_PAYLOAD
//         );

//         expect(peerConnection.peer.signal).toBeCalledWith(TEST_SIGNAL_DATA);
//       });
//     });

//     describe('when processed message type is DEVICE_DETAILS', () => {
//       it('should call socket.emit() to get partner device IP', async () => {
//         peerConnection.socket = ({
//           emit: jest.fn(),
//         } as unknown) as SocketIOClient.Socket;

//         // @ts-ignore
//         processMessage.mockImplementation(() => {
//           return {
//             type: 'DEVICE_DETAILS',
//             payload: TEST_DEVICE_DETAILS_PAYLOAD,
//           };
//         });

//         await handleRecieveEncryptedMessage(
//           peerConnection,
//           TEST_DUMMY_ENCRYPTED_MESSAGE_PAYLOAD
//         );

//         expect(peerConnection.socket.emit).toBeCalledWith(
//           'GET_IP_BY_SOCKET_ID',
//           expect.anything(),
//           expect.anything()
//         );
//       });
//     });

//     describe('when processed message type is GET_APP_THEME', () => {
//       it('should call .sendEncryptedMessage with proper payload', async () => {
//         peerConnection.sendEncryptedMessage = jest.fn();
//         const TEST_GET_APP_THEME_PAYLOAD = {
//           type: 'APP_THEME',
//           payload: { value: getAppTheme() },
//         };
//         // @ts-ignore
//         processMessage.mockImplementation(() => {
//           return {
//             type: 'GET_APP_THEME',
//             payload: {},
//           };
//         });

//         await handleRecieveEncryptedMessage(
//           peerConnection,
//           TEST_DUMMY_ENCRYPTED_MESSAGE_PAYLOAD
//         );

//         expect(peerConnection.sendEncryptedMessage).toBeCalledWith(
//           TEST_GET_APP_THEME_PAYLOAD
//         );
//       });
//     });

//     describe('when processed message type is GET_APP_LANGUAGE', () => {
//       it('should call .sendEncryptedMessage with proper payload', async () => {
//         peerConnection.sendEncryptedMessage = jest.fn();
//         const TEST_GET_APP_LANGUAGE_PAYLOAD = {
//           type: 'APP_LANGUAGE',
//           payload: { value: getAppLanguage() },
//         };
//         // @ts-ignore
//         processMessage.mockImplementation(() => {
//           return {
//             type: 'GET_APP_LANGUAGE',
//             payload: {},
//           };
//         });

//         await handleRecieveEncryptedMessage(
//           peerConnection,
//           TEST_DUMMY_ENCRYPTED_MESSAGE_PAYLOAD
//         );

//         expect(peerConnection.sendEncryptedMessage).toBeCalledWith(
//           TEST_GET_APP_LANGUAGE_PAYLOAD
//         );
//       });
//     });
//   });

//   describe('when handleDeviceIPMessage was called properly', () => {
//     it('should set partnerDeviceDetails with message payload and call device connected callback', async () => {
//       const TEST_DEVICE_IP = '123.123.123.123';
//       const TEST_DEVICE_TO_BE_SET = {
//         deviceIP: TEST_DEVICE_IP,
//         deviceType: TEST_DEVICE_DETAILS_PAYLOAD.deviceType,
//         deviceOS: TEST_DEVICE_DETAILS_PAYLOAD.os,
//         deviceBrowser: TEST_DEVICE_DETAILS_PAYLOAD.browser,
//         deviceScreenWidth: TEST_DEVICE_DETAILS_PAYLOAD.deviceScreenWidth,
//         deviceScreenHeight: TEST_DEVICE_DETAILS_PAYLOAD.deviceScreenHeight,
//         sharingSessionID: peerConnection.sharingSessionID,
//         id: uuid.v4(),
//       };
//       peerConnection.onDeviceConnectedCallback = jest.fn();
//       handleDeviceIPMessage(TEST_DEVICE_IP, peerConnection, {
//         type: 'DEVICE_DETAILS',
//         payload: TEST_DEVICE_DETAILS_PAYLOAD,
//       });

//       expect(peerConnection.partnerDeviceDetails).toEqual(
//         TEST_DEVICE_TO_BE_SET
//       );
//       expect(peerConnection.onDeviceConnectedCallback).toBeCalledWith(
//         TEST_DEVICE_TO_BE_SET
//       );
//     });
//   });
// });