// /* eslint-disable @typescript-eslint/ban-ts-comment */

// import { BrowserWindow, app, ipcMain, screen } from 'electron';
// import settings from 'electron-settings';
// import DeskreenApp from './main.dev';
// import initGlobals from './utils/mainProcessHelpers/initGlobals';
// import signalingServer from './server';
// import MenuBuilder from './menu';
// import i18n from './configs/i18next.config';
// import getDeskreenGlobal from './utils/mainProcessHelpers/getDeskreenGlobal';
// import ConnectedDevicesService from './features/ConnectedDevicesService';
// import SharingSessionService from './features/SharingSessionService';
// import RendererWebrtcHelpersService from './features/PeerConnectionHelperRendererService';
// import installExtensions from './utils/installExtensions';

// const sourceMapSupport = require('source-map-support');
// const electronDebug = require('electron-debug');
// const electronDevToolsInstaller = require('electron-devtools-installer');

// const TEST_SIGNALING_SERVER_PORT = '4343';
// const TEST_DISPLAY_ID = 'd1';
// const TEST_DISPLAY_SIZE = { width: 600, height: 400 };
// const TEST_SCREEN_GET_ALL_DISPLAYS_RESULT = [
//   { id: 'd1', size: { width: 600, height: 400 } },
//   { id: 'd2' },
//   { id: 'd3' },
// ];
// const TEST_CONNECTED_DEVICES_SERVICE = ({
//   sdf: 'fda',
// } as unknown) as ConnectedDevicesService;
// const TEST_ROOM_ID_SERVICE = ({
//   a223: '2g2g',
// } as unknown) as ConnectedDevicesService;
// const testMapSharingSessions = new Map();
// testMapSharingSessions.set('1', {
//   denyConnectionForPartner: jest.fn(),
//   destroy: jest.fn(),
// });
// testMapSharingSessions.set('2', {
//   denyConnectionForPartner: jest.fn(),
//   destroy: jest.fn(),
// });
// const TEST_SHARING_SESSIONS_SERVICE = ({
//   waitingForConnectionSharingSession: '2342a',
//   sharingSessions: testMapSharingSessions,
// } as unknown) as SharingSessionService;
// const testMapHelpers = new Map();
// testMapHelpers.set('1', { close: jest.fn() });
// testMapHelpers.set('2', { close: jest.fn() });
// const TEST_RENDERER_WEBRTC_HELPERS_SERVICE = ({
//   helpers: testMapHelpers,
// } as unknown) as RendererWebrtcHelpersService;
// const mockGlobal = {
//   connectedDevicesService: TEST_CONNECTED_DEVICES_SERVICE,
//   roomIDService: TEST_ROOM_ID_SERVICE,
//   sharingSessionService: TEST_SHARING_SESSIONS_SERVICE,
//   rendererWebrtcHelpersService: TEST_RENDERER_WEBRTC_HELPERS_SERVICE,
// };

// jest.useFakeTimers();

// jest.mock('./utils/installExtensions');
// jest.mock('./utils/AppUpdater');
// jest.mock('./main.dev', () => {
//   return {
//     __esModule: true, // this property makes it work
//     default: jest.requireActual('./main.dev').default,
//   };
// });
// jest.mock('./utils/mainProcessHelpers/getDeskreenGlobal');
// jest.mock('./utils/mainProcessHelpers/initGlobals');
// jest.mock('electron', () => {
//   return {
//     app: {
//       quit: jest.fn(),
//       on: jest.fn(),
//       getName: jest.fn(),
//       getVersion: jest.fn(),
//       commandLine: {
//         appendSwitch: jest.fn(),
//       },
//       whenReady: jest
//         .fn()
//         .mockReturnValue(new Promise((resolve) => resolve(undefined))),
//     },
//     ipcMain: {
//       handle: jest.fn(),
//       on: jest.fn(),
//     },
//     screen: {
//       getAllDisplays: jest
//         .fn()
//         .mockReturnValue(TEST_SCREEN_GET_ALL_DISPLAYS_RESULT),
//     },
//     BrowserWindow: jest.fn().mockReturnValue({
//       loadURL: jest.fn(),
//       on: jest.fn(),
//       webContents: {
//         on: jest.fn(),
//         toggleDevTools: jest.fn(),
//       },
//       minimize: jest.fn(),
//       show: jest.fn(),
//       focus: jest.fn(),
//     }),
//   };
// });
// jest.mock('./server', () => {
//   return {
//     start: jest.fn(),
//     port: TEST_SIGNALING_SERVER_PORT,
//   };
// });
// jest.mock('source-map-support', () => {
//   return {
//     install: jest.fn(),
//   };
// });
// jest.mock('electron-debug');
// jest.mock('electron-devtools-installer', () => {
//   return {
//     default: jest.fn(),
//     REACT_DEVELOPER_TOOLS: 'REACT_DEVELOPER_TOOLS',
//     REDUX_DEVTOOLS: 'REDUX_DEVTOOLS',
//   };
// });
// jest.mock('./configs/i18next.config', () => {
//   return {
//     on: jest.fn(),
//     changeLanguage: jest.fn(),
//     off: jest.fn(),
//     language: 'ua',
//   };
// });
// jest.mock('./menu');
// jest.mock('electron-settings', () => {
//   return {
//     set: jest.fn(),
//   };
// });

// describe('app main.dev tests', () => {
//   let testApp: DeskreenApp;

//   beforeEach(() => {
//     jest.clearAllMocks();
//     jest.restoreAllMocks();
//     // @ts-ignore
//     MenuBuilder.mockClear();
//     // @ts-ignore
//     installExtensions.mockClear();

//     testApp = new DeskreenApp();
//   });

//   describe('when DeskreenApp created properly', () => {
//     describe('when .start() was called', () => {
//       it('should call initGlobals', () => {
//         testApp.start();

//         expect(initGlobals).toBeCalled();
//       });

//       it('should call signalingServer.start()', () => {
//         testApp.start();

//         expect(signalingServer.start).toBeCalled();
//       });

//       it('should call .initElectronAppObject()', () => {
//         testApp.initElectronAppObject = jest.fn();

//         testApp.start();

//         expect(testApp.initElectronAppObject).toBeCalled();
//       });

//       it('should call .initIpcMain()', () => {
//         testApp.initIpcMain = jest.fn();

//         testApp.start();

//         expect(testApp.initIpcMain).toBeCalled();
//       });

//       describe('when initElectronAppObject was called', () => {
//         it('should set app.on("window-all-closed" listener', () => {
//           testApp.initElectronAppObject();

//           expect(app.on).toHaveBeenCalledWith(
//             'window-all-closed',
//             expect.anything()
//           );
//         });

//         it('should call app.commandLine.appendSwitch with "webrtc-max-cpu-consumption-percentage","100"', () => {
//           testApp.initElectronAppObject();

//           expect(app.commandLine.appendSwitch).toHaveBeenCalledWith(
//             'webrtc-max-cpu-consumption-percentage',
//             '100'
//           );
//         });

//         describe('when process.env.E2E_BUILD !== "true"', () => {
//           it('should set app.on("ready" listener', () => {
//             const processEnvBackup = process.env.E2E_BUILD;
//             process.env.E2E_BUILD = 'false';

//             testApp.initElectronAppObject();

//             expect(app.on).toHaveBeenCalledWith('ready', expect.anything());

//             process.env.E2E_BUILD = processEnvBackup;
//           });
//         });

//         describe('when process.env.E2E_BUILD === "true"', () => {
//           it('should set app.on("ready" listener', () => {
//             const processEnvBackup = process.env.E2E_BUILD;
//             process.env.E2E_BUILD = 'true';

//             testApp.initElectronAppObject();

//             expect(app.whenReady).toHaveBeenCalled();

//             process.env.E2E_BUILD = processEnvBackup;
//           });
//         });

//         describe('when app.on("window-all-closed" event occured', () => {
//           describe('when running on NOT darwin platform', () => {
//             it('should call app.quit()', () => {
//               const processBackup = process;
//               // @ts-ignore
//               // eslint-disable-next-line no-global-assign
//               process = {
//                 ...processBackup,
//                 platform: 'linux',
//               };

//               testApp.initElectronAppObject();

//               // @ts-ignore
//               const callback = app.on.mock.calls[0][1];
//               callback();

//               expect(app.quit).toBeCalled();

//               // @ts-ignore
//               // eslint-disable-next-line no-global-assign
//               process = processBackup;
//             });
//           });

//           describe('when running on darwin platform', () => {
//             it('should NOT call app.quit()', () => {
//               const processBackup = process;
//               // @ts-ignore
//               // eslint-disable-next-line no-global-assign
//               process = {
//                 ...processBackup,
//                 platform: 'darwin',
//               };

//               testApp.initElectronAppObject();

//               // @ts-ignore
//               const callback = app.on.mock.calls[0][1];
//               callback();

//               expect(app.quit).not.toBeCalled();

//               // @ts-ignore
//               // eslint-disable-next-line no-global-assign
//               process = processBackup;
//             });
//           });
//         });

//         describe('when app.on("activate" event occured', () => {
//           it('should call .createWindow if mainWindow is null', () => {
//             testApp.mainWindow = null;
//             testApp.createWindow = jest.fn();

//             testApp.initElectronAppObject();

//             // @ts-ignore
//             const callback = app.on.mock.calls[2][1];
//             callback({ preventDefault: () => {} });

//             expect(testApp.createWindow).toBeCalled();
//           });

//           it('should NOT call .createWindow if mainWindow is not null', () => {
//             testApp.mainWindow = ({
//               asdf: 'agasg',
//             } as unknown) as BrowserWindow;
//             testApp.createWindow = jest.fn();

//             testApp.initElectronAppObject();

//             // @ts-ignore
//             const callback = app.on.mock.calls[2][1];
//             callback({ preventDefault: () => {} });

//             expect(testApp.createWindow).not.toBeCalled();
//           });
//         });
//       });

//       describe('when initIpcMain was called', () => {
//         it('should set ipcMain.on("client-changed-language" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.on).toHaveBeenCalledWith(
//             'client-changed-language',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("get-signaling-server-port" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'get-signaling-server-port',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("get-all-displays" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'get-all-displays',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("get-display-size-by-display-id" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'get-display-size-by-display-id',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("main-window-onbeforeunload" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'main-window-onbeforeunload',
//             expect.anything()
//           );
//         });

//         describe('when ipcMain.on("client-changed-language" callback was called', () => {
//           it('should call i18n.changeLanguage and settings.set("appLanguage", newLangCode)', async () => {
//             const testNewLang = 'bz';

//             testApp.initIpcMain();

//             // @ts-ignore
//             const callback = ipcMain.on.mock.calls[0][1];
//             await callback(undefined, testNewLang);

//             expect(i18n.changeLanguage).toHaveBeenCalledWith(testNewLang);
//             expect(settings.set).toHaveBeenCalledWith(
//               'appLanguage',
//               testNewLang
//             );
//           });
//         });

//         describe('when ipcMain.on("get-signaling-server-port" callback was called', () => {
//           describe('when main window is defined', () => {
//             it('should send a signaling server port to main window', () => {
//               testApp.mainWindow = ({
//                 webContents: { send: jest.fn() },
//               } as unknown) as BrowserWindow;

//               testApp.initIpcMain();

//               // @ts-ignore
//               const callback = ipcMain.handle.mock.calls[0][1];
//               callback();

//               expect(testApp.mainWindow.webContents.send).toHaveBeenCalledWith(
//                 'sending-port-from-main',
//                 TEST_SIGNALING_SERVER_PORT
//               );
//             });
//           });
//         });

//         describe('when ipcMain.on("get-all-displays" callback was called', () => {
//           it('should return screen.getAllDisplays() result', () => {
//             testApp.initIpcMain();

//             // @ts-ignore
//             const callback = ipcMain.handle.mock.calls[1][1];
//             const res = callback();

//             expect(res).toBe(TEST_SCREEN_GET_ALL_DISPLAYS_RESULT);
//             expect(screen.getAllDisplays).toBeCalled();
//           });
//         });

//         describe('when ipcMain.on("get-display-size-by-display-id" callback was called', () => {
//           describe('when displayID exists in screen.getAllDisplays() result', () => {
//             it('should return display size as expected', () => {
//               testApp.initIpcMain();

//               // @ts-ignore
//               const callback = ipcMain.handle.mock.calls[2][1];
//               const res = callback(undefined, TEST_DISPLAY_ID);

//               expect(res).toEqual(TEST_DISPLAY_SIZE);
//             });
//           });

//           describe('when displayID NOT exist in screen.getAllDisplays() result', () => {
//             it('should return undefined expected', () => {
//               testApp.initIpcMain();

//               // @ts-ignore
//               const callback = ipcMain.handle.mock.calls[2][1];
//               const res = callback(undefined, 'dagaw22ds');

//               expect(res).toBe(undefined);
//             });
//           });
//         });

//         describe('when ipcMain.on("main-window-onbeforeunload" callback was called', () => {
//           it('should reset globals', () => {
//             // @ts-ignore
//             getDeskreenGlobal.mockReturnValue(mockGlobal);

//             testApp.initIpcMain();

//             // @ts-ignore
//             const callback = ipcMain.handle.mock.calls[3][1];
//             callback();

//             const deskreenGlobal = getDeskreenGlobal();

//             expect(deskreenGlobal.connectedDevicesService).not.toBe(
//               TEST_CONNECTED_DEVICES_SERVICE
//             );
//             expect(deskreenGlobal.roomIDService).not.toBe(TEST_ROOM_ID_SERVICE);
//             testMapSharingSessions.forEach((s) => {
//               expect(s.denyConnectionForPartner).toBeCalled();
//               expect(s.destroy).toBeCalled();
//             });
//             testMapHelpers.forEach((s) => {
//               expect(s.close).toBeCalled();
//             });

//             expect(
//               deskreenGlobal.sharingSessionService
//                 .waitingForConnectionSharingSession
//             ).toBe(null);
//             expect(testMapHelpers.size).toBe(0);
//             expect(testMapSharingSessions.size).toBe(0);
//           });
//         });

//         describe('when createWindow is called', () => {
//           describe('when in dev environment', () => {
//             it('should call installExtensions', async () => {
//               // @ts-ignore
//               // installExtensions = jest.fn();
//               const processEnvNodeEnvBackup = process.env.NODE_ENV;
//               process.env.NODE_ENV = 'development';

//               await testApp.createWindow();

//               expect(installExtensions).toBeCalledTimes(1);

//               process.env.NODE_ENV = processEnvNodeEnvBackup;

//               const processDebugProdBackup = process.env.DEBUG_PROD;
//               process.env.DEBUG_PROD = 'true';

//               await testApp.createWindow();

//               expect(installExtensions).toBeCalledTimes(2);

//               process.env.DEBUG_PROD = processDebugProdBackup;
//             });
//           });

//           describe('when mainWindow is created', () => {
//             it('should call .mainWindow.loadURL with proper parameter', () => {
//               testApp.createWindow();

//               expect(testApp.mainWindow?.loadURL).toHaveBeenCalledWith(
//                 `file://${__dirname}/app.html`
//               );
//             });

//             it('should set .mainWindow.webContents.on("did-finish-load"', () => {
//               testApp.createWindow();

//               expect(testApp.mainWindow?.webContents.on).toHaveBeenCalledWith(
//                 'did-finish-load',
//                 expect.anything()
//               );
//             });

//             describe('when process.env.NODE_ENV === "dev"', () => {
//               it('should call this.mainWindow.webContents.toggleDevTools', () => {
//                 const backProcEnvNodeEnv = process.env.NODE_ENV;
//                 process.env.NODE_ENV = 'dev';

//                 testApp.createWindow();

//                 expect(
//                   testApp.mainWindow?.webContents.toggleDevTools
//                 ).toBeCalled();

//                 process.env.NODE_ENV = backProcEnvNodeEnv;
//               });
//             });

//             describe('when .mainWindow?.webContents.on("did-finish-load" callback called', () => {
//               describe('when mainWindow is not defined', () => {
//                 it('should throw an error', () => {
//                   testApp.createWindow();

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.webContents.on.mock.calls[0][1];

//                   testApp.mainWindow = null;

//                   try {
//                     callback();
//                     // eslint-disable-next-line jest/no-jasmine-globals
//                     fail();
//                   } catch (e) {
//                     // eslint-disable-next-line jest/no-try-expect
//                     expect(e).toEqual(new Error('"mainWindow" is not defined'));
//                   }
//                 });
//               });

//               describe('when process.env.START_MINIMIZED is defined', () => {
//                 it('should call mainWindow.minimize', () => {
//                   testApp.createWindow();
//                   const backProcessEnvStartMinimized =
//                     process.env.START_MINIMIZED;
//                   process.env.START_MINIMIZED = 'true';

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.webContents.on.mock.calls[0][1];

//                   callback();

//                   expect(testApp.mainWindow?.minimize).toBeCalled();

//                   process.env.START_MINIMIZED = backProcessEnvStartMinimized;
//                 });
//               });

//               describe('when process.env.START_MINIMIZED is NOT defined', () => {
//                 it('should call mainWindow.show and mainWindow.focus', () => {
//                   testApp.createWindow();
//                   const backProcessEnvStartMinimized =
//                     process.env.START_MINIMIZED;
//                   process.env.START_MINIMIZED = 'false';

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.webContents.on.mock.calls[0][1];

//                   callback();

//                   expect(testApp.mainWindow?.show).toBeCalled();
//                   expect(testApp.mainWindow?.focus).toBeCalled();

//                   process.env.START_MINIMIZED = backProcessEnvStartMinimized;
//                 });
//               });
//             });

//             describe('when .mainWindow?.on("closed" callback called', () => {
//               it('should set main window to null', () => {
//                 testApp.createWindow();
//                 const callback =
//                   // @ts-ignore
//                   testApp.mainWindow.on.mock.calls[0][1];

//                 callback();

//                 expect(testApp.mainWindow).toBeNull();
//               });
//               describe('when process.platform !== "darwin"', () => {
//                 it('should call app.quit()', () => {
//                   const processBackup = process;
//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = {
//                     ...processBackup,
//                     platform: 'linux',
//                   };
//                   testApp.createWindow();

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.on.mock.calls[0][1];

//                   callback();

//                   expect(app.quit).toBeCalled();

//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = processBackup;
//                 });
//               });

//               describe('when process.platform === "darwin"', () => {
//                 it('should call app.quit()', () => {
//                   const processBackup = process;
//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = {
//                     ...processBackup,
//                     platform: 'darwin',
//                   };
//                   testApp.createWindow();

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.on.mock.calls[0][1];

//                   callback();

//                   expect(app.quit).not.toBeCalled();

//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = processBackup;
//                 });
//               });
//             });
//           });
//         });
//       });

//       describe('when process.env.NODE_ENV === "production"', () => {
//         it('should call sourceMapSupport to be called when ', () => {
//           const envNodeEnvBackup = process.env.NODE_ENV;
//           process.env.NODE_ENV = 'production';

//           testApp.start();

//           expect(sourceMapSupport.install).toBeCalled();

//           process.env.NODE_ENV = envNodeEnvBackup;
//         });
//       });

//       describe('when process.env.NODE_ENV === "development"', () => {
//         it('should call electron-debug ', () => {
//           const envNodeEnvBackup = process.env.NODE_ENV;
//           process.env.NODE_ENV = 'development';

//           testApp.start();

//           expect(electronDebug).toBeCalled();

//           process.env.NODE_ENV = envNodeEnvBackup;
//         });
//       });

//       describe('when process.env.DEBUG_PROD === "true"', () => {
//         it('should call electron-debug ', () => {
//           const envDebugProdBackup = process.env.DEBUG_PROD;
//           process.env.DEBUG_PROD = 'true';

//           testApp.start();

//           expect(electronDebug).toBeCalled();

//           process.env.DEBUG_PROD = envDebugProdBackup;
//         });
//       });
//     });

//     describe('when .initI18n() was called', () => {
//       it('should init i18n object with .on("loaded" event', () => {
//         testApp.initI18n();

//         expect(i18n.on).toBeCalledWith('loaded', expect.anything());
//       });

//       it('should init i18n object with .on("languageChanged" event', () => {
//         testApp.initI18n();

//         expect(i18n.on).toBeCalledWith('languageChanged', expect.anything());
//       });

//       describe('when "loaded" event occured', () => {
//         it('should call changleLanguage("en") and i18n.off("loaded"', () => {
//           testApp.initI18n();
//           // @ts-ignore
//           const callback = i18n.on.mock.calls[0][1];

//           callback();

//           expect(i18n.changeLanguage).toBeCalledWith('en');
//           expect(i18n.off).toBeCalledWith('loaded');
//         });
//       });

//       describe('when "languageChanged" event occured', () => {
//         describe('when mainWindow is defined', () => {
//           it('should create new MenuBuilder', () => {
//             testApp.mainWindow = ({} as unknown) as BrowserWindow;
//             testApp.initI18n();
//             // @ts-ignore
//             const callback = i18n.on.mock.calls[1][1];

//             callback();

//             expect(MenuBuilder).toHaveBeenCalledTimes(1);
//             expect(MenuBuilder).toHaveBeenCalledWith(testApp.mainWindow, i18n);
//           });

//           it('should call .buildMenu() of menuBuilder', () => {
//             testApp.mainWindow = ({} as unknown) as BrowserWindow;
//             testApp.initI18n();
//             // @ts-ignore
//             const callback = i18n.on.mock.calls[1][1];

//             callback();

//             // @ts-ignore
//             const mockMenuBuilderInstance = MenuBuilder.mock.instances[0];

//             expect(mockMenuBuilderInstance.buildMenu).toBeCalled();
//           });

//           it('should call setTimeout with callback and delay', () => {
//             testApp.mainWindow = ({} as unknown) as BrowserWindow;
//             testApp.initI18n();
//             // @ts-ignore
//             const callback = i18n.on.mock.calls[1][1];

//             callback();

//             expect(setTimeout).toHaveBeenCalledWith(expect.anything(), 400);
//           });

//           describe('when setTimeout callback triggered after delay', () => {
//             describe('when should really change app lang', () => {
//               it('should call i18n.changeLanguage with passed language', () => {
//                 const testLng = 'bg';
//                 testApp.mainWindow = ({} as unknown) as BrowserWindow;
//                 testApp.initI18n();
//                 // @ts-ignore
//                 const callback = i18n.on.mock.calls[1][1];
//                 callback(testLng);
//                 // @ts-ignore
//                 const timeoutCallback = setTimeout.mock.calls[0][0];

//                 timeoutCallback();

//                 expect(i18n.changeLanguage).toHaveBeenCalledWith(testLng);
//               });

//               it('should set "appLanguage" in electron-settings', async () => {
//                 const testLng = 'bg';
//                 testApp.mainWindow = ({} as unknown) as BrowserWindow;
//                 testApp.initI18n();
//                 // @ts-ignore
//                 const callback = i18n.on.mock.calls[1][1];
//                 callback(testLng);
//                 // @ts-ignore
//                 const timeoutCallback = setTimeout.mock.calls[0][0];

//                 await timeoutCallback();

//                 expect(settings.set).toHaveBeenCalledWith(
//                   'appLanguage',
//                   testLng
//                 );
//               });
//             });
//           });
//         });
//       });
//     });
//   });

//   describe('when installExtensions was called', () => {
//     it('should call electron-devtools-installer with "REACT_DEVELOPER_TOOLS" and "REDUX_DEVTOOLS"', async () => {
//       // @ts-ignore
//       installExtensions.mockImplementation(
//         jest.requireActual('./utils/installExtensions').default
//       );

//       await installExtensions();

//       expect(electronDevToolsInstaller.default).toBeCalledWith(
//         'REDUX_DEVTOOLS',
//         !!process.env.UPGRADE_EXTENSIONS
//       );
//       expect(electronDevToolsInstaller.default).toBeCalledWith(
//         'REACT_DEVELOPER_TOOLS',
//         !!process.env.UPGRADE_EXTENSIONS
//       );
//     });
//   });
// });