passbolt-browser-extension 5.13.0 → 5.14.2

package/src/chrome-mv3/serviceWorker/service/addUsersToGroup/requestAddUsersToGroupOffscreenService.test.js

@@ -0,0 +1,116 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.13.0
+ */
+
+import Validator from "validator";
+import { v4 as uuidv4 } from "uuid";
+import HandleOffscreenResponseService from "../offscreen/handleOffscreenResponseService";
+import { SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN } from "../../../offscreens/service/group/addUsersToGroupOffscreenService";
+import { RequestAddUsersToGroupOffscreenService } from "./requestAddUsersToGroupOffscreenService";
+import ResponseAddUsersToGroupOffscreenService from "./responseAddUsersToGroupOffscreenService";
+import AccountEntity from "../../../../all/background_page/model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../../../all/background_page/model/entity/account/accountEntity.test.data";
+import GroupUpdateDryRunResultEntity from "../../../../all/background_page/model/entity/group/update/groupUpdateDryRunResultEntity";
+import ProgressService from "../../../../all/background_page/service/progress/progressService";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("RequestAddUsersToGroupOffscreenService", () => {
+  describe("::sendOffscreenMessage", () => {
+    it("should send a message to the offscreen document", async () => {
+      expect.assertions(1);
+      const id = uuidv4();
+      const data = { addUsersToGroupContent: {} };
+      const target = SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN;
+
+      await RequestAddUsersToGroupOffscreenService.sendOffscreenMessage(id, data);
+
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith({ id, data, target });
+    });
+  });
+
+  describe("::decryptAndEncryptSecrets", () => {
+    it("should send a message to the offscreen document and stack the response callback handlers", async () => {
+      expect.assertions(7);
+
+      let sentMessage;
+      jest.spyOn(chrome.runtime, "sendMessage").mockImplementationOnce((message) => {
+        sentMessage = message;
+        HandleOffscreenResponseService._offscreenResponsePromisesCallbacks[message.id].resolve();
+      });
+
+      const account = new AccountEntity(defaultAccountDto());
+      const passphrase = "ada@passbolt.com";
+      const groupUpdateDryRunEntity = new GroupUpdateDryRunResultEntity({ secrets: [], needed_secrets: [] });
+      const progressService = new ProgressService(null, "RequestAddUsersToGroupOffscreenService");
+      const requestPromise = RequestAddUsersToGroupOffscreenService.decryptAndEncryptSecrets(
+        account,
+        passphrase,
+        groupUpdateDryRunEntity,
+        {},
+        progressService,
+      );
+
+      const addUserToGroup = {
+        privateKey: {
+          armoredKey: account.userPrivateArmoredKey,
+          passphrase: passphrase,
+        },
+        secrets: groupUpdateDryRunEntity.secrets.toDto(),
+        neededSecrets: groupUpdateDryRunEntity.neededSecrets.toDto(),
+        usersPublicKeys: {},
+      };
+
+      jest.spyOn(ResponseAddUsersToGroupOffscreenService, "setProgressService");
+
+      expect(requestPromise).toBeInstanceOf(Promise);
+      await expect(requestPromise).resolves.not.toThrow();
+
+      expect(Validator.isUUID(sentMessage.id)).toBe(true);
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledTimes(1);
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith({
+        id: sentMessage.id,
+        data: { requestId: sentMessage.id, addUsersToGroupContent: addUserToGroup },
+        target: SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN,
+      });
+      expect(ResponseAddUsersToGroupOffscreenService.setProgressService).toHaveBeenCalledTimes(1);
+      expect(ResponseAddUsersToGroupOffscreenService.setProgressService).toHaveBeenCalledWith(
+        sentMessage.id,
+        progressService,
+      );
+    });
+
+    it("should throw if the message cannot be sent to the offscreen document for unexpected reason", async () => {
+      expect.assertions(1);
+      jest.spyOn(chrome.runtime, "sendMessage").mockImplementationOnce(() => {
+        throw new Error("Test error");
+      });
+
+      const account = new AccountEntity(defaultAccountDto());
+      const groupUpdateDryRunEntity = new GroupUpdateDryRunResultEntity([]);
+      const progressService = new ProgressService(null, "RequestAddUsersToGroupOffscreenService");
+
+      await expect(() =>
+        RequestAddUsersToGroupOffscreenService.decryptAndEncryptSecrets(
+          account,
+          "test",
+          groupUpdateDryRunEntity,
+          {},
+          progressService,
+        ),
+      ).rejects.toThrow();
+    });
+  });
+});

package/src/chrome-mv3/serviceWorker/service/addUsersToGroup/responseAddUsersToGroupOffscreenService.js

@@ -0,0 +1,99 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.13.0
+ */
+
+import {
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_ERROR,
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_PROGRESS,
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_SUCCESS,
+} from "../../../offscreens/service/group/addUsersToGroupOffscreenService";
+
+const ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPES = [
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_SUCCESS,
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_PROGRESS,
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_ERROR,
+];
+
+export default class ResponseAddUsersToGroupOffscreenService {
+  /**
+   * Progress services registered per offscreen request id.
+   * @type {Object<string, ProgressService>}
+   * @private
+   */
+  static _progressServices = {};
+
+  /**
+   * Handle add user to group decryption and encryption response
+   * @param {object} message.
+   * @param {{resolve: function, reject: function}} callbacks the offscreen response callback.
+   * @return {void}
+   */
+  static handleAddUsersToGroupResponse(message, callbacks) {
+    ResponseAddUsersToGroupOffscreenService.assertMessage(message);
+
+    const { type, data } = message;
+
+    // The request is over (success or error): the progress service is no longer needed.
+    delete ResponseAddUsersToGroupOffscreenService._progressServices[message.id];
+
+    if (type === ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_SUCCESS) {
+      callbacks.resolve(data);
+    } else {
+      callbacks.reject(new Error(data.message));
+    }
+  }
+
+  /**
+   * Handle progress message offscreen response.
+   * @param {object} message.
+   * @return {void}
+   */
+  static handleAddUsersToGroupProgress(message) {
+    ResponseAddUsersToGroupOffscreenService.assertMessage(message);
+
+    const { type, data } = message;
+
+    if (type === ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_PROGRESS) {
+      ResponseAddUsersToGroupOffscreenService._progressServices[message.id]?.updateStepMessage(data.message);
+    }
+  }
+
+  /**
+   * Register the progress service for a given offscreen request id.
+   * @param {string} requestId The offscreen request id.
+   * @param {ProgressService} progressService
+   * @returns {void}
+   */
+  static setProgressService(requestId, progressService) {
+    ResponseAddUsersToGroupOffscreenService._progressServices[requestId] = progressService;
+  }
+
+  /**
+   * Assert message data.
+   * @param {object} message The message.
+   * @throws {Error} If the message.data is not an object.
+   * @throws {Error} If the message.type is not valid.
+   * @private
+   */
+  static assertMessage(message) {
+    if (!ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPES.includes(message?.type)) {
+      throw new Error(
+        `ResponseAddUsersToGroupOffscreenService: message.type should be one of the following ${ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPES.join(", ")}.`,
+      );
+    }
+
+    if (!(message?.data instanceof Object)) {
+      throw new Error("ResponseAddUsersToGroupOffscreenService: message.data should be an object.");
+    }
+  }
+}

package/src/chrome-mv3/serviceWorker/service/addUsersToGroup/responseAddUsersToGroupOffscreenService.test.data.js

@@ -0,0 +1,45 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.13.0
+ */
+
+import {
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_ERROR,
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_PROGRESS,
+  ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_SUCCESS,
+  SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_HANDLER,
+  SEND_MESSAGE_TARGET_OFFSCREEN_PROGRESS_SERVICE_HANDLER,
+} from "../../../offscreens/service/group/addUsersToGroupOffscreenService";
+
+export const successAddUsersToGroupResponseMessage = (message = {}) => ({
+  id: crypto.randomUUID(),
+  type: ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_SUCCESS,
+  target: SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_HANDLER,
+  data: {},
+  ...message,
+});
+
+export const errorAddUsersToGroupResponseMessage = (message = {}) => ({
+  id: crypto.randomUUID(),
+  type: ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_ERROR,
+  target: SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_HANDLER,
+  data: {},
+  ...message,
+});
+
+export const progressAddUsersToGroupResponseMessage = (message = {}) => ({
+  id: crypto.randomUUID(),
+  type: ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_TYPE_PROGRESS,
+  target: SEND_MESSAGE_TARGET_OFFSCREEN_PROGRESS_SERVICE_HANDLER,
+  data: {},
+  ...message,
+});

package/src/chrome-mv3/serviceWorker/service/addUsersToGroup/responseAddUsersToGroupOffscreenService.test.js

@@ -0,0 +1,87 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.13.0
+ */
+
+import { defaultCallbacks } from "../network/responseFetchOffscreenService.test.data";
+import {
+  errorAddUsersToGroupResponseMessage,
+  progressAddUsersToGroupResponseMessage,
+  successAddUsersToGroupResponseMessage,
+} from "./responseAddUsersToGroupOffscreenService.test.data";
+import ResponseAddUsersToGroupOffscreenService from "./responseAddUsersToGroupOffscreenService";
+import { defaultProgressService } from "../../../../all/background_page/service/progress/progressService.test.data";
+
+describe("ResponseAddUsersToGroupOffscreenService", () => {
+  describe("::handleAddUsersToGroupResponse", () => {
+    it("should resolve the promise from the response callback", () => {
+      expect.assertions(1);
+
+      const id = crypto.randomUUID();
+      const callbacks = defaultCallbacks();
+
+      const message = successAddUsersToGroupResponseMessage({ id });
+      ResponseAddUsersToGroupOffscreenService.handleAddUsersToGroupResponse(message, callbacks);
+
+      expect(callbacks.resolve).toHaveBeenCalledTimes(1);
+    });
+
+    it("should reject the promise from the response callback", () => {
+      expect.assertions(1);
+
+      const id = crypto.randomUUID();
+      const callbacks = defaultCallbacks();
+
+      const message = errorAddUsersToGroupResponseMessage({ id });
+      ResponseAddUsersToGroupOffscreenService.handleAddUsersToGroupResponse(message, callbacks);
+
+      expect(callbacks.reject).toHaveBeenCalledTimes(1);
+    });
+
+    it("should clear the request progress service once the response is handled", () => {
+      expect.assertions(1);
+
+      const id = crypto.randomUUID();
+      const callbacks = defaultCallbacks();
+      const progressService = defaultProgressService({ goals: 10 });
+      ResponseAddUsersToGroupOffscreenService.setProgressService(id, progressService);
+
+      const message = successAddUsersToGroupResponseMessage({ id });
+      ResponseAddUsersToGroupOffscreenService.handleAddUsersToGroupResponse(message, callbacks);
+
+      expect(ResponseAddUsersToGroupOffscreenService._progressServices[id]).toBeUndefined();
+    });
+  });
+
+  describe("::handleAddUsersToGroupProgress", () => {
+    it("should update progress message of the progress service registered for the request id", () => {
+      expect.assertions(2);
+
+      const id = crypto.randomUUID();
+      const progressService = defaultProgressService({ goals: 10 });
+      const message = progressAddUsersToGroupResponseMessage({ id, data: { message: "update message" } });
+      ResponseAddUsersToGroupOffscreenService.setProgressService(id, progressService);
+      ResponseAddUsersToGroupOffscreenService.handleAddUsersToGroupProgress(message);
+
+      expect(progressService.updateStepMessage).toHaveBeenCalledTimes(1);
+      expect(progressService.updateStepMessage).toHaveBeenCalledWith(message.data.message);
+    });
+
+    it("should not throw when no progress service is registered for the request id", () => {
+      expect.assertions(1);
+
+      const message = progressAddUsersToGroupResponseMessage({ data: { message: "update message" } });
+
+      expect(() => ResponseAddUsersToGroupOffscreenService.handleAddUsersToGroupProgress(message)).not.toThrow();
+    });
+  });
+});

package/src/chrome-mv3/serviceWorker/service/network/requestFetchOffscreenService.js

@@ -41,7 +41,6 @@ export class RequestFetchOffscreenService {
     const fetchStrategy = (await RequestFetchOffscreenService.isFetchOffscreenPreferred())
       ? RequestFetchOffscreenService.fetchOffscreen
       : RequestFetchOffscreenService.fetchNative;
-
     return fetchStrategy(resource, options);
   }
 

package/src/chrome-mv3/serviceWorker/service/offscreen/handleOffscreenResponseService.js

@@ -20,6 +20,11 @@ import {
 import { SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER } from "../../../offscreens/service/offscreen/handleOffscreenRequestService";
 import ResponseClipboardOffscreenService from "../clipboard/responseClipboardOffscreenService";
 import ResponseFetchOffscreenService from "../network/responseFetchOffscreenService";
+import {
+  SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_HANDLER,
+  SEND_MESSAGE_TARGET_OFFSCREEN_PROGRESS_SERVICE_HANDLER,
+} from "../../../offscreens/service/group/addUsersToGroupOffscreenService";
+import ResponseAddUsersToGroupOffscreenService from "../addUsersToGroup/responseAddUsersToGroupOffscreenService";
 
 export default class HandleOffscreenResponseService {
   /**
@@ -36,6 +41,10 @@ export default class HandleOffscreenResponseService {
     [SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER]: ResponseFetchOffscreenService.handleFetchResponse,
     [SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER]:
       ResponseClipboardOffscreenService.handleClipboardResponse,
+    [SEND_MESSAGE_TARGET_ADD_USERS_TO_GROUP_OFFSCREEN_RESPONSE_HANDLER]:
+      ResponseAddUsersToGroupOffscreenService.handleAddUsersToGroupResponse,
+    [SEND_MESSAGE_TARGET_OFFSCREEN_PROGRESS_SERVICE_HANDLER]:
+      ResponseAddUsersToGroupOffscreenService.handleAddUsersToGroupProgress,
     [SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER]: HandleOffscreenResponseService.handleOffscreenError,
   };
 
@@ -50,6 +59,12 @@ export default class HandleOffscreenResponseService {
     }
 
     const responseHandler = HandleOffscreenResponseService.REPONSE_HANDLE_MAP[message.target];
+
+    if (message.target === SEND_MESSAGE_TARGET_OFFSCREEN_PROGRESS_SERVICE_HANDLER) {
+      responseHandler(message);
+      return;
+    }
+
     if (!responseHandler) {
       console.debug("HandleOffscreenResponseService received response not specific to offscreen.");
       return;

package/src/firefox/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 2,
   "name": "__MSG_appName__",
   "short_name": "passbolt",
-  "version": "5.13.0",
+  "version": "5.14.2",
   "description": "__MSG_appDescription__",
   "default_locale": "en",
   "browser_specific_settings": {

package/src/safari/background_page/index.js

@@ -14,12 +14,7 @@
 import PortManager from "../../all/background_page/sdk/port/portManager";
 import SystemRequirementService from "../../all/background_page/service/systemRequirementService/systemRequirementService";
 import OnExtensionInstalledController from "../../all/background_page/controller/extension/onExtensionInstalledController";
-import User from "../../all/background_page/model/user";
-import Log from "../../all/background_page/model/log";
-import CheckAuthStatusService from "../../all/background_page/service/auth/checkAuthStatusService";
 import GlobalAlarmService from "../../all/background_page/service/alarm/globalAlarmService";
-import PostLoginService from "../../all/background_page/service/auth/postLoginService";
-import PostLogoutService from "../../all/background_page/service/auth/postLogoutService";
 import OnStartUpService from "../../all/background_page/service/extension/onStartUpService";
 import ToolbarService from "../../all/background_page/service/toolbar/toolbarService";
 import WebNavigationService from "../../all/background_page/service/webNavigation/webNavigationService";
@@ -29,38 +24,6 @@ const main = async () => {
    * Load all system requirement
    */
   await SystemRequirementService.get();
-
-  // When the extension is updated and the user is still connected, an event needs to be sent
-  checkAndProcessIfUserAuthenticated();
-};
-
-/**
- * Check and process event if the user is authenticated
- * @return {Promise<void>}
- */
-const checkAndProcessIfUserAuthenticated = async () => {
-  const user = User.getInstance();
-  // Check if user is valid
-  if (!user.isValid()) {
-    return;
-  }
-
-  let authStatus;
-  try {
-    const checkAuthStatusService = new CheckAuthStatusService();
-    authStatus = await checkAuthStatusService.checkAuthStatus(true);
-  } catch (error) {
-    console.error(error);
-    // Service is unavailable, do nothing...
-    Log.write({ level: "debug", message: "The Service is unavailable to check if the user is authenticated" });
-    return;
-  }
-
-  if (authStatus.isAuthenticated) {
-    PostLoginService.exec();
-  } else {
-    PostLogoutService.exec();
-  }
 };
 
 main();

package/src/safari/common/polyfill/safariBrowserPolyfill.js

@@ -11,27 +11,27 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         5.5.0
  */
-const browser = require("webextension-polyfill");
+const browserPolyfill = require("webextension-polyfill");
 const ScriptingPolyfill = require("./../../../all/common/polyfill/scriptingPolyfill");
 const SessionStoragePolyfill = require("./../../../all/common/polyfill/sessionStoragePolyfill");
 const OnInstalledReasonPolyfill = require("./onInstalledReasonPolyfill");
 
 // mv3 scripting API for mv2
-if (!browser.scripting) {
-  browser.scripting = new ScriptingPolyfill(browser);
+if (!browserPolyfill.scripting) {
+  browserPolyfill.scripting = new ScriptingPolyfill(browserPolyfill);
 }
 // mv3 session storage API polyfill
-if (!browser.storage.session) {
-  browser.storage.session = new SessionStoragePolyfill();
+if (!browserPolyfill.storage.session) {
+  browserPolyfill.storage.session = new SessionStoragePolyfill();
 }
 // mv3 action API polyfill for mv2
-if (!browser.action) {
-  browser.action = browser.browserAction;
+if (!browserPolyfill.action) {
+  browserPolyfill.action = browserPolyfill.browserAction;
 }
 
 // OnInstaledReason polyfill for Safari
-if (!browser.runtime.OnInstalledReason) {
-  OnInstalledReasonPolyfill(browser.runtime);
+if (!browserPolyfill.runtime.OnInstalledReason) {
+  OnInstalledReasonPolyfill(browserPolyfill.runtime);
 }
 
-module.exports = browser;
+module.exports = browserPolyfill;

package/src/safari/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 2,
   "name": "Passbolt - password manager",
   "short_name": "passbolt",
-  "version": "5.13.0",
+  "version": "5.14.2",
   "description": "Passbolt extension for the open source password manager.",
   "default_locale": "en",
   "icons": {

package/test/jest.setup.js

@@ -20,7 +20,8 @@ import "./mocks/mockCryptoKey";
 import "./matchers/extendExpect";
 import MockNavigatorLocks from "./mocks/mockNavigatorLocks";
 import MockNavigatorClipboard from "./mocks/mockNavigatorClipboard";
-import OrganizationSettingsModel from "../src/all/background_page/model/organizationSettings/organizationSettingsModel";
+import SiteSettingsRuntimeCache from "../src/all/background_page/service/siteSettings/siteSettingsRuntimeCache";
+import SiteSettingsLocalStorage from "../src/all/background_page/service/local_storage/siteSettingsLocalStorage";
 import { Config } from "../src/all/background_page/model/config";
 import Keyring from "../src/all/background_page/model/keyring";
 import ResourceLocalStorage from "../src/all/background_page/service/local_storage/resourceLocalStorage";
@@ -71,7 +72,8 @@ beforeEach(async () => {
   // Flush the session storage
   await browser.storage.session.clear();
   // Flush caches
-  OrganizationSettingsModel.flushCache();
+  SiteSettingsRuntimeCache.flushAll();
+  SiteSettingsLocalStorage._runtimeCachedData = {};
   ResourceLocalStorage.flush();
   FolderLocalStorage.flush();
   GroupLocalStorage._runtimeCachedData = {};

package/src/all/background_page/controller/group/getOrFindGroupsUsersController.test.js

@@ -1,69 +0,0 @@
-/**
- * Passbolt ~ Open source password manager for teams
- * Copyright (c) Passbolt SA (https://www.passbolt.com)
- *
- * Licensed under GNU Affero General Public License version 3 of the or any later version.
- * For full copyright and license information, please see the LICENSE.txt
- * Redistributions of files must retain the above copyright notice.
- *
- * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
- * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
- * @link          https://www.passbolt.com Passbolt(tm)
- * @since         5.13.0
- */
-
-import AccountEntity from "../../model/entity/account/accountEntity";
-import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
-import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
-import GetOrFindGroupsUsersController from "./getOrFindGroupsUsersController";
-import GroupsUsersCollection from "passbolt-styleguide/src/shared/models/entity/groupUser/groupsUsersCollection";
-import { defaultGroupsDtos } from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection.test.data";
-
-beforeEach(() => {
-  jest.clearAllMocks();
-});
-
-describe("GetOrFindGroupsUsersController", () => {
-  describe("::exec", () => {
-    it("Should retrieve the members of the requested group.", async () => {
-      expect.assertions(3);
-
-      const account = new AccountEntity(defaultAccountDto());
-      const groupsDto = defaultGroupsDtos(1, { withGroupsUsers: 3 });
-      const targetGroup = groupsDto[0];
-      const groupsUsersCollection = new GroupsUsersCollection(targetGroup.groups_users);
-      const controller = new GetOrFindGroupsUsersController(null, null, defaultApiClientOptions(), account);
-      jest
-        .spyOn(controller.getOrFindGroupsUsersService, "getOrFindByGroupId")
-        .mockImplementation(() => groupsUsersCollection);
-
-      const result = await controller.exec(targetGroup.id);
-
-      expect(result).toBeInstanceOf(GroupsUsersCollection);
-      expect(result).toStrictEqual(groupsUsersCollection);
-      expect(controller.getOrFindGroupsUsersService.getOrFindByGroupId).toHaveBeenCalledWith(targetGroup.id);
-    });
-
-    it("Should let error been thrown from the service if any.", async () => {
-      expect.assertions(1);
-
-      const account = new AccountEntity(defaultAccountDto());
-      const controller = new GetOrFindGroupsUsersController(null, null, defaultApiClientOptions(), account);
-      const groupId = defaultGroupsDtos()[0].id;
-      jest.spyOn(controller.getOrFindGroupsUsersService, "getOrFindByGroupId").mockImplementation(() => {
-        throw new Error("Something went wrong!");
-      });
-
-      await expect(() => controller.exec(groupId)).rejects.toThrow();
-    });
-
-    it("Should assert its parameter.", async () => {
-      expect.assertions(1);
-
-      const account = new AccountEntity(defaultAccountDto());
-      const controller = new GetOrFindGroupsUsersController(null, null, defaultApiClientOptions(), account);
-
-      await expect(() => controller.exec("not-a-uuid")).rejects.toThrow("The given parameter is not a valid UUID");
-    });
-  });
-});

package/src/all/background_page/controller/organizationSettings/getOrganizationSettingsController.js

@@ -1,55 +0,0 @@
-/**
- * Passbolt ~ Open source password manager for teams
- * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
- *
- * Licensed under GNU Affero General Public License version 3 of the or any later version.
- * For full copyright and license information, please see the LICENSE.txt
- * Redistributions of files must retain the above copyright notice.
- *
- * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
- * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
- * @link          https://www.passbolt.com Passbolt(tm)
- * @since         3.6.0
- */
-
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
-
-class GetOrganizationSettingsController {
-  /**
-   * GetOrganizationSettingsController constructor
-   * @param {Worker} worker
-   * @param {string} requestId uuid
-   * @param {ApiClientOptions} apiClientOptions
-   */
-  constructor(worker, requestId, apiClientOptions) {
-    this.worker = worker;
-    this.requestId = requestId;
-    this.organizationSettingsModel = new OrganizationSettingsModel(apiClientOptions);
-  }
-
-  /**
-   * Wrapper of exec function to run it with worker.
-   *
-   * @return {Promise<void>}
-   */
-  async _exec() {
-    try {
-      const result = await this.exec();
-      this.worker.port.emit(this.requestId, "SUCCESS", result);
-    } catch (error) {
-      console.error(error);
-      this.worker.port.emit(this.requestId, "ERROR", error);
-    }
-  }
-
-  /**
-   * Get the organization settings.
-   *
-   * @return {Promise<OrganizationSettingsEntity>}
-   */
-  async exec() {
-    return this.organizationSettingsModel.getOrFind(true);
-  }
-}
-
-export default GetOrganizationSettingsController;