Chore/user config handling and performance fixes

src/ElectronBackend/main/__tests__/menu.test.ts

@@ -5,7 +5,7 @@
 import electron, { BrowserWindow, MenuItemConstructorOptions } from 'electron';
 
 import { createMenu } from '../menu';
-import { UserSettings } from '../user-settings';
+import { UserSettingsProvider } from '../user-settings-provider';
 
 jest.mock('electron', () => ({
   BrowserWindow: class BrowserWindowMock {},
@@ -48,7 +48,7 @@ describe('create menu', () => {
   ];
   testCases.forEach((testCase) => {
     it(`evaluates ${testCase.darkMode ? 'dark' : 'light'} mode properly`, async () => {
-      await UserSettings.init();
+      await UserSettingsProvider.init();
       const mainWindow = new BrowserWindow();
 
       // Important to set this up only here and not in the mock setup

src/ElectronBackend/main/__tests__/user-settings-provider.test.ts

@@ -0,0 +1,149 @@
+// SPDX-FileCopyrightText: Meta Platforms, Inc. and its affiliates
+// SPDX-FileCopyrightText: TNG Technology Consulting GmbH <https://www.tngtech.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+import { BrowserWindow } from 'electron';
+import settings from 'electron-settings';
+import { rmSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { AllowedFrontendChannels } from '../../../shared/ipc-channels';
+import {
+  DEFAULT_PANEL_SIZES,
+  DEFAULT_USER_SETTINGS,
+} from '../../../shared/shared-constants';
+import { UserSettingsProvider } from '../user-settings-provider';
+
+type MockedBrowserWindow = BrowserWindow & {
+  sendFunction: (channel: string, ...args: Array<unknown>) => void;
+};
+
+jest.mock('electron', () => {
+  const sendFunction = jest.fn();
+  return {
+    BrowserWindow: {
+      getAllWindows: () => {
+        return [
+          {
+            webContents: {
+              send: sendFunction,
+            },
+          },
+        ];
+      },
+      sendFunction,
+    },
+  };
+});
+describe('UserSettings', () => {
+  let temporaryDir: string | undefined = undefined;
+  beforeEach(async () => {
+    temporaryDir = await mkdtemp(join(tmpdir(), 'OpossumUiTesting-'));
+    settings.configure({ dir: temporaryDir, atomicSave: true });
+  });
+
+  afterEach(() => {
+    if (temporaryDir) {
+      rmSync(temporaryDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('init', () => {
+    it('sets up the default values if empty', async () => {
+      await UserSettingsProvider.init();
+
+      const result = await settings.get();
+
+      expect(result).toEqual(DEFAULT_USER_SETTINGS);
+    });
+
+    it('overwrites only the non set values if there are already values set', async () => {
+      await settings.set('qaMode', true);
+
+      await UserSettingsProvider.init();
+
+      const result = await settings.get();
+
+      expect(result).toEqual({ ...DEFAULT_USER_SETTINGS, qaMode: true });
+    });
+
+    it('resets everything if reset is requested', async () => {
+      const oldEnvironment = process.env;
+      process.env = { ...oldEnvironment, RESET: 'TRUE' };
+
+      await settings.set('qaMode', true);
+
+      await UserSettingsProvider.init();
+
+      const result = await settings.get();
+
+      expect(result).toEqual({ ...DEFAULT_USER_SETTINGS });
+      process.env = oldEnvironment;
+    });
+  });
+  describe('get', () => {
+    it('gets a user setting from a predescribed path', async () => {
+      await UserSettingsProvider.init();
+
+      const panelSizes = await UserSettingsProvider.get('panelSizes');
+
+      expect(panelSizes).toEqual(DEFAULT_PANEL_SIZES);
+    });
+
+    it('gets the full user settings', async () => {
+      await UserSettingsProvider.init();
+
+      const userSettings = await UserSettingsProvider.get();
+
+      expect(userSettings).toEqual(DEFAULT_USER_SETTINGS);
+    });
+  });
+
+  describe('write operations', () => {
+    it('sets a value and communicates to the frontend', async () => {
+      await UserSettingsProvider.set('qaMode', true);
+
+      const qaMode = await UserSettingsProvider.get('qaMode');
+      expect(qaMode).toBe(true);
+      expect(
+        (BrowserWindow as unknown as MockedBrowserWindow).sendFunction,
+      ).toHaveBeenCalledWith(AllowedFrontendChannels.UserSettingsChanged, {
+        qaMode: true,
+      });
+    });
+
+    it('sets a value and does not communicates to the frontend if disabled', async () => {
+      await UserSettingsProvider.set('qaMode', true, {
+        skipNotification: true,
+      });
+
+      const qaMode = await UserSettingsProvider.get('qaMode');
+      expect(qaMode).toBe(true);
+      expect(
+        (BrowserWindow as unknown as MockedBrowserWindow).sendFunction,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('allows to update multiple values at once', async () => {
+      await UserSettingsProvider.init();
+
+      await UserSettingsProvider.update({
+        qaMode: true,
+        showClassifications: false,
+      });
+
+      const userSettings = await UserSettingsProvider.get();
+
+      expect(
+        (BrowserWindow as unknown as MockedBrowserWindow).sendFunction,
+      ).toHaveBeenCalledTimes(2);
+      expect(userSettings).toEqual({
+        ...DEFAULT_USER_SETTINGS,
+        qaMode: true,
+        showClassifications: false,
+      });
+    });
+  });
+});

src/ElectronBackend/main/main.ts

@@ -6,6 +6,7 @@ import { dialog, ipcMain, Menu, systemPreferences } from 'electron';
 import os from 'os';
 
 import { AllowedFrontendChannels, IpcChannel } from '../../shared/ipc-channels';
+import { UserSettings } from '../../shared/shared-types';
 import { getMessageBoxContentForErrorsWrapper } from '../errorHandling/errorHandling';
 import { createWindow, loadWebApp } from './createWindow';
 import {
@@ -21,7 +22,7 @@ import {
 import { createMenu } from './menu';
 import { DisabledMenuItemHandler } from './menu/DisabledMenuItemHandler';
 import { openFileFromCliOrEnvVariableIfProvided } from './openFileFromCliOrEnvVariableIfProvided';
-import { UserSettings } from './user-settings';
+import { UserSettingsProvider } from './user-settings-provider';
 
 export async function main(): Promise<void> {
   try {
@@ -35,7 +36,7 @@ export async function main(): Promise<void> {
 
     const mainWindow = createWindow();
 
-    await UserSettings.init();
+    await UserSettingsProvider.init();
     Menu.setApplicationMenu(await createMenu(mainWindow));
 
     mainWindow.webContents.session.webRequest.onBeforeSendHeaders(
@@ -93,10 +94,15 @@ export async function main(): Promise<void> {
     );
     ipcMain.handle(IpcChannel.OpenLink, openLinkListener);
     ipcMain.handle(IpcChannel.GetUserSettings, (_, key) =>
-      UserSettings.get(key),
+      UserSettingsProvider.get(key),
     );
-    ipcMain.handle(IpcChannel.SetUserSettings, (_, { key, value }) =>
-      UserSettings.set(key, value, { skipNotification: true }),
+    ipcMain.handle(IpcChannel.GetFullUserSettings, () =>
+      UserSettingsProvider.get(),
+    );
+    ipcMain.handle(
+      IpcChannel.SetUserSettings,
+      (_, userSettings: Partial<UserSettings>) =>
+        UserSettingsProvider.update(userSettings, true),
     );
 
     await loadWebApp(mainWindow);

src/ElectronBackend/main/menu/viewMenu.ts

@@ -7,7 +7,7 @@ import { MenuItemConstructorOptions } from 'electron';
 
 import { text } from '../../../shared/text';
 import { getIconBasedOnTheme } from '../iconHelpers';
-import { UserSettings } from '../user-settings';
+import { UserSettingsProvider } from '../user-settings-provider';
 import { switchableMenuItem } from './switchableMenuItem';
 
 function getShowDevTools(): MenuItemConstructorOptions {
@@ -61,7 +61,7 @@ function getShowClassifications(
     id: 'show-classifications',
     label: text.menu.viewSubmenu.showClassifications,
     onToggle: (newState: boolean) =>
-      UserSettings.set('showClassifications', newState),
+      UserSettingsProvider.set('showClassifications', newState),
   });
 }
 
@@ -72,22 +72,25 @@ function getShowCriticality(
     id: 'show-criticality',
     label: text.menu.viewSubmenu.showCriticality,
     onToggle: (newState: boolean) =>
-      UserSettings.set('showCriticality', newState),
+      UserSettingsProvider.set('showCriticality', newState),
   });
 }
 
 function getQaMode(qaMode: boolean | null): Array<MenuItemConstructorOptions> {
   return switchableMenuItem(qaMode, {
     id: 'qa-mode',
     label: text.menu.viewSubmenu.qaMode,
-    onToggle: (newState: boolean) => UserSettings.set('qaMode', newState),
+    onToggle: (newState: boolean) =>
+      UserSettingsProvider.set('qaMode', newState),
   });
 }
 
 export async function getViewMenu(): Promise<MenuItemConstructorOptions> {
-  const qaMode = await UserSettings.get('qaMode');
-  const showCriticality = await UserSettings.get('showCriticality');
-  const showClassifications = await UserSettings.get('showClassifications');
+  const qaMode = await UserSettingsProvider.get('qaMode');
+  const showCriticality = await UserSettingsProvider.get('showCriticality');
+  const showClassifications = await UserSettingsProvider.get(
+    'showClassifications',
+  );
   return {
     label: text.menu.view,
     submenu: [

src/ElectronBackend/main/user-settings-provider.ts

@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: Meta Platforms, Inc. and its affiliates
+// SPDX-FileCopyrightText: TNG Technology Consulting GmbH <https://www.tngtech.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+import { BrowserWindow } from 'electron';
+import log from 'electron-log';
+import settings from 'electron-settings';
+
+import { AllowedFrontendChannels } from '../../shared/ipc-channels';
+import { DEFAULT_USER_SETTINGS } from '../../shared/shared-constants';
+import {
+  UserSettings as IUserSettings,
+  UserSettings,
+} from '../../shared/shared-types';
+
+export class UserSettingsProvider {
+  public static async init() {
+    if (process.argv.includes('--reset') || process.env.RESET) {
+      log.info('Resetting user settings');
+      await settings.set(DEFAULT_USER_SETTINGS as unknown as never);
+    } else {
+      const currentSettings = await settings.get();
+      await settings.set({
+        ...DEFAULT_USER_SETTINGS,
+        ...currentSettings,
+      });
+    }
+  }
+
+  public static get<T extends keyof IUserSettings>(
+    path: T,
+  ): Promise<IUserSettings[T]>;
+  public static get(): Promise<IUserSettings>;
+  public static get<T extends keyof IUserSettings>(
+    path?: T,
+  ): Promise<IUserSettings[T]> | Promise<IUserSettings> {
+    if (path) {
+      return settings.get(path) as Promise<IUserSettings[T]>;
+    }
+    return settings.get() as unknown as Promise<IUserSettings>;
+  }
+
+  public static async update(
+    userSettings: Partial<IUserSettings>,
+    skipNotification: boolean = false,
+  ): Promise<void> {
+    for (const key of Object.keys(userSettings)) {
+      const properKey = key as keyof UserSettings;
+      if (userSettings[properKey] !== undefined) {
+        await UserSettingsProvider.set(properKey, userSettings[properKey], {
+          skipNotification,
+        });
+      }
+    }
+  }
+
+  public static async set<T extends keyof IUserSettings>(
+    path: T,
+    value: IUserSettings[T],
+    { skipNotification }: { skipNotification?: boolean } = {},
+  ): Promise<void> {
+    await settings.set(path, value);
+
+    if (!skipNotification) {
+      const partialSettingsToUpdate = Object.fromEntries([[path, value]]);
+      BrowserWindow.getAllWindows().forEach((window) => {
+        window.webContents.send(
+          AllowedFrontendChannels.UserSettingsChanged,
+          partialSettingsToUpdate,
+        );
+      });
+    }
+  }
+}