passbolt-browser-extension 5.13.0 → 5.14.2

package/src/all/background_page/service/siteSettings/findSiteSettingsService.js

@@ -0,0 +1,47 @@
+/**
+ * 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         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import SiteSettingsApiService from "../api/siteSettings/siteSettingsApiService";
+
+class FindSiteSettingsService {
+  /**
+   * @param {ApiClientOptions} apiClientOptions
+   */
+  constructor(apiClientOptions) {
+    this.siteSettingsApiService = new SiteSettingsApiService(apiClientOptions);
+  }
+
+  /**
+   * Fetch the site settings from the API and return them as a SiteSettingsEntity.
+   * On the cloud, a disabled organization returns 403 — that case is normalized to a
+   * disabled site-settings entity to preserve historical behavior.
+   * @returns {Promise<SiteSettingsEntity>}
+   */
+  async findSiteSettings() {
+    let dto;
+    try {
+      dto = await this.siteSettingsApiService.findSiteSettings();
+    } catch (error) {
+      if (error instanceof PassboltApiFetchError && error?.data?.code === 403) {
+        dto = SiteSettingsEntity.disabledSiteSettings;
+      } else {
+        throw error;
+      }
+    }
+    return new SiteSettingsEntity(dto);
+  }
+}
+
+export default FindSiteSettingsService;

package/src/all/background_page/service/siteSettings/findSiteSettingsService.test.js

@@ -0,0 +1,68 @@
+/**
+ * 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         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import { defaultProSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsApiService from "../api/siteSettings/siteSettingsApiService";
+import FindSiteSettingsService from "./findSiteSettingsService";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("FindSiteSettingsService", () => {
+  describe("::findSiteSettings", () => {
+    it("returns a SiteSettingsEntity built from the API DTO", async () => {
+      expect.assertions(2);
+      const dto = defaultProSiteSettings();
+      jest.spyOn(SiteSettingsApiService.prototype, "findSiteSettings").mockResolvedValue(dto);
+
+      const service = new FindSiteSettingsService(defaultApiClientOptions());
+      const entity = await service.findSiteSettings();
+
+      expect(entity).toBeInstanceOf(SiteSettingsEntity);
+      expect(entity.toDto()).toEqual(dto);
+    });
+
+    it("returns a disabled SiteSettingsEntity on 403 (cloud disabled-org)", async () => {
+      expect.assertions(2);
+      const error = new PassboltApiFetchError("Forbidden", { code: 403 });
+      jest.spyOn(SiteSettingsApiService.prototype, "findSiteSettings").mockRejectedValue(error);
+
+      const service = new FindSiteSettingsService(defaultApiClientOptions());
+      const entity = await service.findSiteSettings();
+
+      expect(entity).toBeInstanceOf(SiteSettingsEntity);
+      expect(entity.toDto()).toEqual({ status: "disabled" });
+    });
+
+    it("rethrows non-403 API errors", async () => {
+      expect.assertions(1);
+      const error = new PassboltApiFetchError("Server error", { code: 500 });
+      jest.spyOn(SiteSettingsApiService.prototype, "findSiteSettings").mockRejectedValue(error);
+
+      const service = new FindSiteSettingsService(defaultApiClientOptions());
+      await expect(service.findSiteSettings()).rejects.toThrow(PassboltApiFetchError);
+    });
+
+    it("rethrows non-PassboltApiFetchError errors", async () => {
+      expect.assertions(1);
+      jest.spyOn(SiteSettingsApiService.prototype, "findSiteSettings").mockRejectedValue(new Error("network down"));
+
+      const service = new FindSiteSettingsService(defaultApiClientOptions());
+      await expect(service.findSiteSettings()).rejects.toThrow("network down");
+    });
+  });
+});

package/src/all/background_page/service/siteSettings/getOrFindSiteSettingsService.js

@@ -0,0 +1,84 @@
+/**
+ * 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         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import SiteSettingsLocalStorage from "../local_storage/siteSettingsLocalStorage";
+import FindAndUpdateSiteSettingsLocalStorageService from "./findAndUpdateSiteSettingsLocalStorageService";
+import SiteSettingsRuntimeCache from "./siteSettingsRuntimeCache";
+import CheckAuthStatusService from "../auth/checkAuthStatusService";
+
+/**
+ * Read entry point for site settings. Successor of the legacy
+ * 'OrganizationSettingsModel.getOrFind'.
+ *
+ * On 'refreshCache=true' (default), the cache step is skipped — every call goes through
+ * to the API. Callers that explicitly opt into cached reads pass 'refreshCache=false',
+ * which picks the cache by authentication state:
+ *   - Authenticated: SiteSettingsLocalStorage (the offline-mode store), else the API.
+ *   - Anonymous: SiteSettingsRuntimeCache (in-memory; populated by any fetch this
+ *     session), else the API.
+ *
+ * The API fall-through goes through FindAndUpdateSiteSettingsLocalStorageService, which
+ * refreshes the caches. Anonymous callers never read SiteSettingsLocalStorage.
+ */
+export default class GetOrFindSiteSettingsService {
+  /**
+   * @param {AccountEntity} account
+   * @param {ApiClientOptions} apiClientOptions
+   */
+  constructor(account, apiClientOptions) {
+    this.account = account;
+    this.siteSettingsLocalStorage = new SiteSettingsLocalStorage(account);
+    this.findAndUpdateSiteSettingsLocalStorageService = new FindAndUpdateSiteSettingsLocalStorageService(
+      account,
+      apiClientOptions,
+    );
+    this.checkAuthStatusService = new CheckAuthStatusService(account, apiClientOptions);
+  }
+
+  /**
+   * @param {boolean} [refreshCache=true] When true (default), bypass caches and hit the API.
+   * Pass false to read from the cache selected by authentication state (LS when
+   * authenticated, runtime cache when anonymous) before falling back to the API.
+   * @returns {Promise<SiteSettingsEntity>}
+   */
+  async getOrFind(refreshCache = true) {
+    if (!refreshCache) {
+      const activeSession = await this.checkAuthStatusService.checkAuthStatus();
+
+      if (activeSession.isAuthenticated) {
+        const lsDto = await this.siteSettingsLocalStorage.get();
+        if (lsDto) {
+          const siteSettings = new SiteSettingsEntity(lsDto);
+          /*
+           * Mirror the persisted settings into the in-memory runtime cache. The cache is
+           * service-worker-lifetime and is flushed on login (postLoginService) and lost on
+           * service-worker restart, whereas SiteSettingsLocalStorage survives both. Seeding it
+           * here keeps AppEmailValidatorService.validate - which reads SiteSettingsRuntimeCache
+           * synchronously to validate account usernames - in sync with the persisted settings,
+           * so a custom email validation regex is honored even after the cache has been dropped.
+           */
+          SiteSettingsRuntimeCache.set(siteSettings);
+          return siteSettings;
+        }
+      } else {
+        const cachedDto = SiteSettingsRuntimeCache.get(this.account.id);
+        if (cachedDto) {
+          return new SiteSettingsEntity(cachedDto);
+        }
+      }
+    }
+
+    return this.findAndUpdateSiteSettingsLocalStorageService.findAndUpdateAll();
+  }
+}

package/src/all/background_page/service/siteSettings/getOrFindSiteSettingsService.test.js

@@ -0,0 +1,175 @@
+/**
+ * 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         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import { defaultProSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsLocalStorage from "../local_storage/siteSettingsLocalStorage";
+import SiteSettingsRuntimeCache from "./siteSettingsRuntimeCache";
+import GetOrFindSiteSettingsService from "./getOrFindSiteSettingsService";
+import OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
+import CheckAuthStatusService from "../auth/checkAuthStatusService";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  SiteSettingsRuntimeCache.flushAll();
+  SiteSettingsLocalStorage._runtimeCachedData = {};
+  // Default to "not authenticated" so anything that doesn't explicitly re-mock stays on the safe path.
+  jest
+    .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
+    .mockResolvedValue(new OnlineSessionEntity({ is_authenticated: false }));
+});
+
+describe("GetOrFindSiteSettingsService", () => {
+  let account, apiClientOptions, service;
+
+  beforeEach(async () => {
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = defaultApiClientOptions();
+    service = new GetOrFindSiteSettingsService(account, apiClientOptions);
+    await service.siteSettingsLocalStorage.flush();
+  });
+
+  describe("::getOrFind (refreshCache=true, default)", () => {
+    it("always hits the API even when the runtime cache is populated", async () => {
+      expect.assertions(3);
+      const stale = new SiteSettingsEntity({ ...defaultProSiteSettings(), serverTimeDiff: 999 });
+      SiteSettingsRuntimeCache.set(stale);
+
+      const fresh = new SiteSettingsEntity(defaultProSiteSettings());
+      const apiSpy = jest
+        .spyOn(service.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService, "findSiteSettings")
+        .mockResolvedValue(fresh);
+
+      const result = await service.getOrFind();
+
+      expect(apiSpy).toHaveBeenCalledTimes(1);
+      expect(result.toDto()).toEqual(fresh.toDto());
+      expect(SiteSettingsRuntimeCache.get()).toEqual(fresh.toDto());
+    });
+
+    it("never reads local storage on this path", async () => {
+      expect.assertions(2);
+      const lsSpy = jest.spyOn(service.siteSettingsLocalStorage, "get");
+      const apiSpy = jest
+        .spyOn(service.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService, "findSiteSettings")
+        .mockResolvedValue(new SiteSettingsEntity(defaultProSiteSettings()));
+
+      await service.getOrFind();
+
+      expect(lsSpy).not.toHaveBeenCalled();
+      expect(apiSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("::getOrFind (refreshCache=false) — authenticated", () => {
+    beforeEach(() => {
+      jest
+        .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
+        .mockResolvedValue(new OnlineSessionEntity({ is_authenticated: true }));
+    });
+
+    it("returns from local storage when populated; no API call", async () => {
+      expect.assertions(3);
+      const dto = defaultProSiteSettings();
+      await service.siteSettingsLocalStorage.set(new SiteSettingsEntity(dto));
+      const apiSpy = jest.spyOn(
+        service.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService,
+        "findSiteSettings",
+      );
+
+      const result = await service.getOrFind(false);
+
+      expect(result.toDto()).toEqual(dto);
+      expect(apiSpy).not.toHaveBeenCalled();
+      // The local storage read must also seed the runtime cache (see next test for why).
+      expect(SiteSettingsRuntimeCache.get()).toEqual(dto);
+    });
+
+    it("seeds the runtime cache from local storage so the synchronous username validator stays consistent", async () => {
+      /*
+       * Regression: SiteSettingsRuntimeCache is the ONLY store AppEmailValidatorService reads
+       * (synchronously, while constructing a user entity). It is flushed on login and lost on
+       * service-worker restart, whereas SiteSettingsLocalStorage survives both. An authenticated
+       * read that hits local storage must therefore repopulate the runtime cache, otherwise a
+       * custom email validation regex would be dropped and valid usernames rejected.
+       */
+      expect.assertions(3);
+      const dto = defaultProSiteSettings();
+      await service.siteSettingsLocalStorage.set(new SiteSettingsEntity(dto));
+      // Emulate a flushed / post-restart runtime cache while local storage still holds the settings.
+      SiteSettingsRuntimeCache.flushAll();
+      expect(SiteSettingsRuntimeCache.get()).toBeNull();
+      const apiSpy = jest.spyOn(
+        service.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService,
+        "findSiteSettings",
+      );
+
+      await service.getOrFind(false);
+
+      expect(SiteSettingsRuntimeCache.get()).toEqual(dto);
+      expect(apiSpy).not.toHaveBeenCalled();
+    });
+
+    it("ignores the runtime cache and falls through to the API on a local storage miss", async () => {
+      expect.assertions(2);
+      // Populate the runtime cache but leave LS empty: an authenticated read must not use
+      // the runtime cache, so it falls through to the API.
+      SiteSettingsRuntimeCache.set(new SiteSettingsEntity({ ...defaultProSiteSettings(), serverTimeDiff: 999 }));
+      const dto = defaultProSiteSettings();
+      const apiSpy = jest
+        .spyOn(service.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService, "findSiteSettings")
+        .mockResolvedValue(new SiteSettingsEntity(dto));
+
+      const result = await service.getOrFind(false);
+
+      expect(apiSpy).toHaveBeenCalledTimes(1);
+      expect(result.toDto()).toEqual(dto);
+    });
+  });
+
+  describe("::getOrFind (refreshCache=false) — unauthenticated", () => {
+    it("returns from the runtime cache when populated; no LS read; no API call", async () => {
+      expect.assertions(3);
+      const dto = defaultProSiteSettings();
+      SiteSettingsRuntimeCache.set(new SiteSettingsEntity(dto));
+      const lsSpy = jest.spyOn(service.siteSettingsLocalStorage, "get");
+      const apiSpy = jest.spyOn(
+        service.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService,
+        "findSiteSettings",
+      );
+
+      const result = await service.getOrFind(false);
+
+      expect(result.toDto()).toEqual(dto);
+      expect(lsSpy).not.toHaveBeenCalled();
+      expect(apiSpy).not.toHaveBeenCalled();
+    });
+
+    it("skips local storage entirely on runtime miss; falls through to the API", async () => {
+      expect.assertions(2);
+      const lsSpy = jest.spyOn(service.siteSettingsLocalStorage, "get");
+      const dto = defaultProSiteSettings();
+      jest
+        .spyOn(service.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService, "findSiteSettings")
+        .mockResolvedValue(new SiteSettingsEntity(dto));
+
+      const result = await service.getOrFind(false);
+
+      expect(lsSpy).not.toHaveBeenCalled();
+      expect(result.toDto()).toEqual(dto);
+    });
+  });
+});

package/src/all/background_page/service/siteSettings/siteSettingsRuntimeCache.js

@@ -0,0 +1,70 @@
+/**
+ * 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         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+
+/**
+ * Per-account in-memory cache of site settings DTOs. Successor of the legacy
+ * `OrganizationSettingsModel._settings`. Service-worker lifetime.
+ *
+ * Auth-agnostic: written by FindAndUpdateSiteSettingsLocalStorageService after every API
+ * fetch, and by GetOrFindSiteSettingsService when seeding from SiteSettingsLocalStorage
+ * on the offline-auth read path. Read by GetOrFindSiteSettingsService.
+ *
+ * Independent of SiteSettingsLocalStorage. The two caches answer different questions:
+ *   - SiteSettingsLocalStorage._runtimeCachedData mirrors browser.storage.local exactly
+ *     and always reflects auth sitesettings value.
+ *   - SiteSettingsRuntimeCache holds the most recent API result for this service-worker
+ *     lifetime, regardless of whether it was persisted to browser.storage.local.
+ * @private
+ */
+let _cache = {};
+
+class SiteSettingsRuntimeCache {
+  /**
+   * Read the cached entry for the given account.
+   * @returns {object|null} the cached DTO, or null when absent.
+   */
+  static get() {
+    return _cache.siteSettings || null;
+  }
+
+  /**
+   * Write the cached entry for the given account.
+   * @param {SiteSettingsEntity} settings
+   * @throws {TypeError} If settings is not a SiteSettingsEntity.
+   */
+  static set(settings) {
+    if (!(settings instanceof SiteSettingsEntity)) {
+      throw new TypeError("Parameter `settings` should be of type SiteSettingsEntity.");
+    }
+    _cache.siteSettings = settings.toDto();
+  }
+
+  /**
+   * Drop the cached entry for an account. Intended for session lifecycle hooks
+   * (logout / account switch).
+   */
+  static flush() {
+    delete _cache.siteSettings;
+  }
+
+  /**
+   * Drop every cached entry. Intended for tests.
+   */
+  static flushAll() {
+    _cache = {};
+  }
+}
+
+export default SiteSettingsRuntimeCache;

package/src/all/background_page/service/sso/generateSsoKitService.test.js

@@ -15,7 +15,7 @@ import "../../../../../test/mocks/mockSsoDataStorage";
 import SsoDataStorage from "../indexedDB_storage/ssoDataStorage";
 import { withAzureSsoSettings } from "../../controller/sso/getCurrentSsoSettingsController.test.data";
 import GenerateSsoKitService from "./generateSsoKitService";
-import { anonymousOrganizationSettings } from "../../model/entity/organizationSettings/organizationSettingsEntity.test.data";
+import { anonymousSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
 import { mockApiResponse } from "../../../../../test/mocks/mockApiResponse";
 import { enableFetchMocks } from "jest-fetch-mock";
 import SsoKitClientPartEntity from "../../model/entity/sso/ssoKitClientPartEntity";
@@ -30,7 +30,7 @@ beforeEach(async () => {
 describe("GenerateSsoKitService", () => {
   describe("GenerateSsoKitService::generate", () => {
     const mockOrganisationSettings = (withSsoEnabled = true) => {
-      const organizationSettings = anonymousOrganizationSettings();
+      const organizationSettings = anonymousSiteSettings();
       organizationSettings.passbolt.plugins.sso = {
         enabled: withSsoEnabled,
       };

package/src/all/background_page/service/toolbar/toolbarService.js

@@ -163,7 +163,9 @@ class ToolbarService {
   async resetSuggestedResourcesBadge() {
     this.tabUrl = null;
     // Should do nothing if the user is not authenticated
-    if (!(await this.isUserAuthenticated())) {
+    const account = await GetActiveAccountService.get();
+    const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+    if (!(await this.isUserAuthenticated(account, apiClientOptions))) {
       return;
     }
     BrowserExtensionIconService.setSuggestedResourcesCount(0);
@@ -178,7 +180,7 @@ class ToolbarService {
       const account = await GetActiveAccountService.get();
       const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
       // Should do nothing if the user is not authenticated
-      if (!(await this.isUserAuthenticated())) {
+      if (!(await this.isUserAuthenticated(account, apiClientOptions))) {
         return;
       }
 
@@ -225,9 +227,9 @@ class ToolbarService {
    * Is the user authenticated
    * @returns {Promise<{boolean}|boolean>}
    */
-  async isUserAuthenticated() {
+  async isUserAuthenticated(account, apiClientOptions) {
     try {
-      const checkAuthStatusService = new CheckAuthStatusService();
+      const checkAuthStatusService = new CheckAuthStatusService(account, apiClientOptions);
       // use the cached data as the worker could wake up every 30 secondes.
       const authStatus = await checkAuthStatusService.checkAuthStatus(false);
       return authStatus.isAuthenticated;

package/src/all/background_page/service/toolbar/toolbarService.test.js

@@ -24,6 +24,7 @@ import ResourceTypeLocalStorage from "../local_storage/resourceTypeLocalStorage"
 import CheckAuthStatusService from "../auth/checkAuthStatusService";
 import User from "../../../../all/background_page/model/user";
 import OpenWebsiteGettingStartedPageService from "../ui/openWebsiteGettingStartedPageService";
+import OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
 
 jest.useFakeTimers();
 
@@ -57,7 +58,7 @@ describe("ToolbarService", () => {
       jest.spyOn(browser.tabs, "query").mockImplementation(() => [{ url: "https://www.wherever.com" }]);
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest.spyOn(ResourceLocalStorage, "get").mockImplementation(() => defaultResourceDtosCollection());
-      jest.spyOn(ResourceTypeLocalStorage, "get").mockImplementation(() => resourceTypesCollectionDto());
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "getData").mockImplementation(() => resourceTypesCollectionDto());
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
         .mockImplementation(() => ({ isAuthenticated: true }));
@@ -76,7 +77,7 @@ describe("ToolbarService", () => {
       jest.spyOn(browser.tabs, "query").mockImplementation(() => [{ url: "https://www.passbolt.com" }]);
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest.spyOn(ResourceLocalStorage, "get").mockImplementation(() => defaultResourceDtosCollection());
-      jest.spyOn(ResourceTypeLocalStorage, "get").mockImplementation(() => resourceTypesCollectionDto());
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "getData").mockImplementation(() => resourceTypesCollectionDto());
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
         .mockImplementation(() => ({ isAuthenticated: true }));
@@ -97,10 +98,10 @@ describe("ToolbarService", () => {
       jest.spyOn(browser.tabs, "query").mockImplementation(() => [{ url: "https://www.wherever.com" }]);
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest.spyOn(ResourceLocalStorage, "get").mockImplementation(() => defaultResourceDtosCollection());
-      jest.spyOn(ResourceTypeLocalStorage, "get").mockImplementation(() => resourceTypesCollectionDto());
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "getData").mockImplementation(() => resourceTypesCollectionDto());
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-        .mockImplementation(() => ({ isAuthenticated: true }));
+        .mockImplementation(() => new OnlineSessionEntity({ is_authenticated: true }));
 
       await toolbarService.handleUserLoggedIn();
       await toolbarService.handleUserLoggedOut();
@@ -118,10 +119,10 @@ describe("ToolbarService", () => {
       jest.spyOn(browser.tabs, "query").mockImplementationOnce(() => [{ url: "https://www.wherever.com" }]);
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest.spyOn(ResourceLocalStorage, "get").mockImplementation(() => defaultResourceDtosCollection());
-      jest.spyOn(ResourceTypeLocalStorage, "get").mockImplementation(() => resourceTypesCollectionDto());
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "getData").mockImplementation(() => resourceTypesCollectionDto());
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-        .mockImplementation(() => ({ isAuthenticated: true }));
+        .mockImplementation(() => new OnlineSessionEntity({ is_authenticated: true }));
 
       await toolbarService.handleUserLoggedIn();
 
@@ -141,10 +142,10 @@ describe("ToolbarService", () => {
       jest.spyOn(browser.tabs, "query").mockImplementationOnce(() => [{ url: "https://www.wherever.com" }]);
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest.spyOn(ResourceLocalStorage, "get").mockImplementation(() => defaultResourceDtosCollection());
-      jest.spyOn(ResourceTypeLocalStorage, "get").mockImplementation(() => resourceTypesCollectionDto());
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "getData").mockImplementation(() => resourceTypesCollectionDto());
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-        .mockImplementation(() => ({ isAuthenticated: true }));
+        .mockImplementation(() => new OnlineSessionEntity({ is_authenticated: true }));
 
       await toolbarService.handleUserLoggedIn();
       expect(browserExtensionIconServiceSetCountMock).toHaveBeenLastCalledWith(0);
@@ -163,10 +164,10 @@ describe("ToolbarService", () => {
       jest.spyOn(browser.tabs, "query").mockImplementationOnce(() => [{ url: "https://www.wherever.com" }]);
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest.spyOn(ResourceLocalStorage, "get").mockImplementation(() => defaultResourceDtosCollection());
-      jest.spyOn(ResourceTypeLocalStorage, "get").mockImplementation(() => resourceTypesCollectionDto());
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "getData").mockImplementation(() => resourceTypesCollectionDto());
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-        .mockImplementation(() => ({ isAuthenticated: true }));
+        .mockImplementation(() => new OnlineSessionEntity({ is_authenticated: true }));
 
       await toolbarService.handleUserLoggedIn();
       expect(browserExtensionIconServiceSetCountMock).toHaveBeenLastCalledWith(0);
@@ -183,10 +184,10 @@ describe("ToolbarService", () => {
       jest.spyOn(browser.tabs, "query").mockImplementationOnce(() => [{ url: "https://www.passbolt.com" }]);
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest.spyOn(ResourceLocalStorage, "get").mockImplementation(() => defaultResourceDtosCollection());
-      jest.spyOn(ResourceTypeLocalStorage, "get").mockImplementation(() => resourceTypesCollectionDto());
+      jest.spyOn(ResourceTypeLocalStorage.prototype, "getData").mockImplementation(() => resourceTypesCollectionDto());
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-        .mockImplementation(() => ({ isAuthenticated: true }));
+        .mockImplementation(() => new OnlineSessionEntity({ is_authenticated: true }));
 
       await toolbarService.handleUserLoggedIn();
       expect(browserExtensionIconServiceSetCountMock).toHaveBeenLastCalledWith(4);
@@ -201,7 +202,7 @@ describe("ToolbarService", () => {
       jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
       jest
         .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-        .mockImplementation(() => ({ isAuthenticated: false }));
+        .mockImplementation(() => new OnlineSessionEntity({ is_authenticated: false }));
 
       await toolbarService.handleSuggestedResourcesOnFocusedWindow(42);
       expect(browserExtensionIconServiceSetCountMock).toHaveBeenCalledTimes(0);

package/src/all/background_page/service/user/findAndUpdateUsersLocalStorageService.js

@@ -13,7 +13,7 @@
  */
 import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
 import UsersCollection from "passbolt-styleguide/src/shared/models/entity/user/usersCollection";
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
+import GetOrFindSiteSettingsService from "../siteSettings/getOrFindSiteSettingsService";
 import UserLocalStorage from "../local_storage/userLocalStorage";
 import FindUsersService from "./findUsersService";
 
@@ -31,7 +31,7 @@ class FindAndUpdateUsersLocalStorageService {
   constructor(account, apiClientOptions) {
     this.account = account;
     this.findUsersService = new FindUsersService(account, apiClientOptions);
-    this.organisationSettingsModel = new OrganizationSettingsModel(apiClientOptions);
+    this.getOrFindSiteSettingsService = new GetOrFindSiteSettingsService(account, apiClientOptions);
     this.lockKey = `${USERS_UPDATE_ALL_LS_LOCK_PREFIX}-${this.account.id}`;
   }
 
@@ -64,8 +64,8 @@ class FindAndUpdateUsersLocalStorageService {
       };
       if (this.account?.roleName === RoleEntity.ROLE_ADMIN) {
         contains.is_mfa_enabled = true;
-        const organizationSettings = await this.organisationSettingsModel.getOrFind();
-        if (organizationSettings.isPluginEnabled("metadata")) {
+        const siteSettings = await this.getOrFindSiteSettingsService.getOrFind(false);
+        if (siteSettings.isPluginEnabled("metadata")) {
           contains.missing_metadata_key_ids = true;
         }
       }

package/src/all/background_page/service/user/findAndUpdateUsersLocalStorageService.test.js

@@ -21,7 +21,7 @@ import FindAndUpdateUsersLocalStorageService from "./findAndUpdateUsersLocalStor
 import FindUsersService from "./findUsersService";
 import UsersCollection from "passbolt-styleguide/src/shared/models/entity/user/usersCollection";
 import UserLocalStorage from "../local_storage/userLocalStorage";
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
+import GetOrFindSiteSettingsService from "../siteSettings/getOrFindSiteSettingsService";
 
 describe("FindAndUpdateUsersLocalStorageService", () => {
   let service, account;
@@ -82,7 +82,7 @@ describe("FindAndUpdateUsersLocalStorageService", () => {
         .spyOn(FindUsersService.prototype, "findAll")
         .mockImplementation(() => new UsersCollection([]));
       jest
-        .spyOn(OrganizationSettingsModel.prototype, "getOrFind")
+        .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
         .mockImplementation(() => ({ isPluginEnabled: (plugin) => plugin === "metadata" }));
 
       await adminService.findAndUpdateAll();
@@ -100,7 +100,7 @@ describe("FindAndUpdateUsersLocalStorageService", () => {
         .spyOn(FindUsersService.prototype, "findAll")
         .mockImplementation(() => new UsersCollection([]));
       jest
-        .spyOn(OrganizationSettingsModel.prototype, "getOrFind")
+        .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
         .mockImplementation(() => ({ isPluginEnabled: () => false }));
 
       await adminService.findAndUpdateAll();