passbolt-browser-extension 5.13.0 → 5.14.2

package/src/all/background_page/service/auth/checkAuthStatusService.js

@@ -14,38 +14,51 @@
 
 import MfaAuthenticationRequiredError from "../../error/mfaAuthenticationRequiredError";
 import AuthenticationStatusService from "../authenticationStatusService";
-import AuthStatusLocalStorage from "../local_storage/authStatusLocalStorage";
+import ActiveSessionLocalStorage from "../local_storage/activeSessionLocalStorage";
+import OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
 
 class CheckAuthStatusService {
+  /**
+   * Constructor
+   *
+   * @param {AccountEntity} account the user account
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(account, apiClientOptions) {
+    this.account = account;
+    this.authenticationStatusService = new AuthenticationStatusService(apiClientOptions);
+    this.activeSessionLocalStorage = new ActiveSessionLocalStorage(account);
+  }
+
   /**
    * Returns the authentication status of the current user.
    * It first interrogates the local storage and if necessary the API afterward.
    * @param {boolean} [flushCache] should the cache be flushed before or not.
-   * @return {Promise<{isAuthenticated: {boolean}, isMfaRequired: {boolean}}>}
+   * @return {Promise<OnlineSessionEntity>}
    * @throws {Error} if something wrong happened on the API
    */
   async checkAuthStatus(flushCache = false) {
-    if (!flushCache) {
-      const storedStatus = await AuthStatusLocalStorage.get();
-      if (storedStatus) {
-        return storedStatus;
-      }
+    const storedSession = await this.activeSessionLocalStorage.get();
+    if (!flushCache && storedSession) {
+      return new OnlineSessionEntity(storedSession);
     }
 
-    let isAuthenticated, isMfaRequired;
+    const session = { ...storedSession };
     try {
-      isAuthenticated = await AuthenticationStatusService.isAuthenticated();
-      isMfaRequired = false;
+      session.is_authenticated = await this.authenticationStatusService.isAuthenticated();
+      session.is_mfa_authenticated = true;
     } catch (error) {
       if (!(error instanceof MfaAuthenticationRequiredError)) {
         throw error;
       }
-      isAuthenticated = true;
-      isMfaRequired = true;
+      session.is_authenticated = true;
+      session.is_mfa_authenticated = false;
     }
 
-    await AuthStatusLocalStorage.set(isAuthenticated, isMfaRequired);
-    return { isAuthenticated, isMfaRequired };
+    const onlineSessionEntity = new OnlineSessionEntity(session);
+    await this.activeSessionLocalStorage.set(onlineSessionEntity);
+    return onlineSessionEntity;
   }
 }
 

package/src/all/background_page/service/auth/checkAuthStatusService.test.js

@@ -13,9 +13,11 @@
  */
 
 import MfaAuthenticationRequiredError from "../../error/mfaAuthenticationRequiredError";
-import AuthenticationStatusService from "../authenticationStatusService";
-import AuthStatusLocalStorage from "../local_storage/authStatusLocalStorage";
 import CheckAuthStatusService from "./checkAuthStatusService";
+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 OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
 
 beforeEach(() => {
   jest.clearAllMocks();
@@ -24,102 +26,118 @@ beforeEach(() => {
 describe("CheckAuthStatusService", () => {
   it("expects the user not to be authenticated", async () => {
     expect.assertions(3);
-    jest.spyOn(AuthStatusLocalStorage, "get").mockImplementation(() => undefined);
-    jest.spyOn(AuthStatusLocalStorage, "flush");
-    jest.spyOn(AuthenticationStatusService, "isAuthenticated").mockImplementation(() => false);
 
-    const service = new CheckAuthStatusService();
+    const account = new AccountEntity(defaultAccountDto());
+    const service = new CheckAuthStatusService(account, defaultApiClientOptions());
+    jest.spyOn(service.activeSessionLocalStorage, "get").mockImplementation(() => undefined);
+    jest.spyOn(service.activeSessionLocalStorage, "flush");
+    jest.spyOn(service.authenticationStatusService, "isAuthenticated").mockImplementation(() => false);
     const authStatus = await service.checkAuthStatus();
 
-    expect(AuthStatusLocalStorage.get).toHaveBeenCalledTimes(1);
-    expect(AuthStatusLocalStorage.flush).not.toHaveBeenCalled();
-    expect(authStatus).toStrictEqual({
-      isAuthenticated: false,
-      isMfaRequired: false,
-    });
+    expect(service.activeSessionLocalStorage.get).toHaveBeenCalledTimes(1);
+    expect(service.activeSessionLocalStorage.flush).not.toHaveBeenCalled();
+    expect(authStatus).toStrictEqual(
+      new OnlineSessionEntity({
+        is_authenticated: false,
+        is_mfa_authenticated: true,
+      }),
+    );
   });
 
   it("expects the user to be fully authenticated", async () => {
     expect.assertions(3);
-    jest.spyOn(AuthStatusLocalStorage, "get").mockImplementation(() => undefined);
-    jest.spyOn(AuthStatusLocalStorage, "flush");
-    jest.spyOn(AuthenticationStatusService, "isAuthenticated").mockImplementation(() => true);
 
-    const service = new CheckAuthStatusService();
+    const account = new AccountEntity(defaultAccountDto());
+    const service = new CheckAuthStatusService(account, defaultApiClientOptions());
+    jest.spyOn(service.activeSessionLocalStorage, "get").mockImplementation(() => undefined);
+    jest.spyOn(service.activeSessionLocalStorage, "flush");
+    jest.spyOn(service.authenticationStatusService, "isAuthenticated").mockImplementation(() => true);
     const authStatus = await service.checkAuthStatus();
 
-    expect(AuthStatusLocalStorage.get).toHaveBeenCalledTimes(1);
-    expect(AuthStatusLocalStorage.flush).not.toHaveBeenCalled();
-    expect(authStatus).toStrictEqual({
-      isAuthenticated: true,
-      isMfaRequired: false,
-    });
+    expect(service.activeSessionLocalStorage.get).toHaveBeenCalledTimes(1);
+    expect(service.activeSessionLocalStorage.flush).not.toHaveBeenCalled();
+    expect(authStatus).toStrictEqual(
+      new OnlineSessionEntity({
+        is_authenticated: true,
+        is_mfa_authenticated: true,
+      }),
+    );
   });
 
   it("expects the user to require MFA authentication", async () => {
     expect.assertions(3);
-    jest.spyOn(AuthStatusLocalStorage, "get").mockImplementation(() => undefined);
-    jest.spyOn(AuthStatusLocalStorage, "flush");
-    jest.spyOn(AuthenticationStatusService, "isAuthenticated").mockImplementation(() => {
+
+    const account = new AccountEntity(defaultAccountDto());
+    const service = new CheckAuthStatusService(account, defaultApiClientOptions());
+    jest.spyOn(service.activeSessionLocalStorage, "get").mockImplementation(() => undefined);
+    jest.spyOn(service.activeSessionLocalStorage, "flush");
+    jest.spyOn(service.authenticationStatusService, "isAuthenticated").mockImplementation(() => {
       throw new MfaAuthenticationRequiredError();
     });
-
-    const service = new CheckAuthStatusService();
     const authStatus = await service.checkAuthStatus();
 
-    expect(AuthStatusLocalStorage.get).toHaveBeenCalledTimes(1);
-    expect(AuthStatusLocalStorage.flush).not.toHaveBeenCalled();
-    expect(authStatus).toStrictEqual({
-      isAuthenticated: true,
-      isMfaRequired: true,
-    });
+    expect(service.activeSessionLocalStorage.get).toHaveBeenCalledTimes(1);
+    expect(service.activeSessionLocalStorage.flush).not.toHaveBeenCalled();
+    expect(authStatus).toStrictEqual(
+      new OnlineSessionEntity({
+        is_authenticated: true,
+        is_mfa_authenticated: false,
+      }),
+    );
   });
 
   it("should ask for an API call to find the authentication status", async () => {
-    expect.assertions(3);
-    jest.spyOn(AuthStatusLocalStorage, "get").mockImplementation(() => undefined);
-    jest.spyOn(AuthStatusLocalStorage, "flush");
-    jest.spyOn(AuthenticationStatusService, "isAuthenticated").mockImplementation(() => true);
-
-    const service = new CheckAuthStatusService();
+    expect.assertions(4);
+
+    const account = new AccountEntity(defaultAccountDto());
+    const service = new CheckAuthStatusService(account, defaultApiClientOptions());
+    jest.spyOn(service.activeSessionLocalStorage, "get").mockImplementation(() => undefined);
+    jest.spyOn(service.activeSessionLocalStorage, "set");
+    jest.spyOn(service.activeSessionLocalStorage, "flush");
+    jest.spyOn(service.authenticationStatusService, "isAuthenticated").mockImplementation(() => true);
     const authStatus = await service.checkAuthStatus(true);
 
-    expect(AuthStatusLocalStorage.get).not.toHaveBeenCalled();
-    expect(AuthStatusLocalStorage.flush).not.toHaveBeenCalled();
-    expect(authStatus).toStrictEqual({
-      isAuthenticated: true,
-      isMfaRequired: false,
-    });
+    expect(service.activeSessionLocalStorage.get).toHaveBeenCalled();
+    expect(service.activeSessionLocalStorage.set).toHaveBeenCalled();
+    expect(service.activeSessionLocalStorage.flush).not.toHaveBeenCalled();
+    expect(authStatus).toStrictEqual(
+      new OnlineSessionEntity({
+        is_authenticated: true,
+        is_mfa_authenticated: true,
+      }),
+    );
   });
 
   it("should return the authentication status from the cache", async () => {
     expect.assertions(3);
-    const localStorageData = {
-      isAuthenticated: false,
-      isMfaRequired: false,
-    };
-    jest.spyOn(AuthStatusLocalStorage, "get").mockImplementation(() => localStorageData);
-    jest.spyOn(AuthStatusLocalStorage, "flush");
-
-    const service = new CheckAuthStatusService();
+    const localStorageData = new OnlineSessionEntity({
+      is_authenticated: false,
+      is_mfa_authenticated: true,
+    });
+
+    const account = new AccountEntity(defaultAccountDto());
+    const service = new CheckAuthStatusService(account, defaultApiClientOptions());
+    jest.spyOn(service.activeSessionLocalStorage, "get").mockImplementation(() => localStorageData);
+    jest.spyOn(service.activeSessionLocalStorage, "flush");
     const authStatus = await service.checkAuthStatus(false);
 
-    expect(AuthStatusLocalStorage.get).toHaveBeenCalledTimes(1);
-    expect(AuthStatusLocalStorage.flush).not.toHaveBeenCalled();
+    expect(service.activeSessionLocalStorage.get).toHaveBeenCalledTimes(1);
+    expect(service.activeSessionLocalStorage.flush).not.toHaveBeenCalled();
     expect(authStatus).toStrictEqual(localStorageData);
   });
 
   it("should return the authentication status from the API if the cache is empty", async () => {
     expect.assertions(3);
-    jest.spyOn(AuthStatusLocalStorage, "get").mockImplementation(() => null);
-    jest.spyOn(AuthStatusLocalStorage, "flush");
-    jest.spyOn(AuthenticationStatusService, "isAuthenticated").mockImplementation(() => false);
 
-    const service = new CheckAuthStatusService();
+    const account = new AccountEntity(defaultAccountDto());
+    const service = new CheckAuthStatusService(account, defaultApiClientOptions());
+    jest.spyOn(service.activeSessionLocalStorage, "get").mockImplementation(() => null);
+    jest.spyOn(service.activeSessionLocalStorage, "flush");
+    jest.spyOn(service.authenticationStatusService, "isAuthenticated").mockImplementation(() => false);
     const authStatus = await service.checkAuthStatus(false);
 
-    expect(AuthStatusLocalStorage.get).toHaveBeenCalledTimes(1);
-    expect(AuthStatusLocalStorage.flush).not.toHaveBeenCalled();
-    expect(authStatus).toStrictEqual({ isAuthenticated: false, isMfaRequired: false });
+    expect(service.activeSessionLocalStorage.get).toHaveBeenCalledTimes(1);
+    expect(service.activeSessionLocalStorage.flush).not.toHaveBeenCalled();
+    expect(authStatus).toStrictEqual(new OnlineSessionEntity({ is_authenticated: false, is_mfa_authenticated: true }));
   });
 });

package/src/all/background_page/service/auth/postLoginService.js

@@ -16,7 +16,7 @@ import toolbarService from "../toolbar/toolbarService";
 import StartLoopAuthSessionCheckService from "./startLoopAuthSessionCheckService";
 import InformCallToActionPagemod from "../../pagemod/informCallToActionPagemod";
 import WorkerService from "../worker/workerService";
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
+import SiteSettingsRuntimeCache from "../siteSettings/siteSettingsRuntimeCache";
 
 class PostLoginService {
   /**
@@ -24,8 +24,8 @@ class PostLoginService {
    * @returns {Promise<void>}
    */
   static async exec() {
-    // Clear cache in the organization settings
-    await OrganizationSettingsModel.flushCache();
+    // Clear the in-memory site settings cache so the next authenticated read refetches.
+    SiteSettingsRuntimeCache.flushAll();
     await PostLoginService.sendLoginEventForWorkers();
     await StartLoopAuthSessionCheckService.exec();
     toolbarService.handleUserLoggedIn();

package/src/all/background_page/service/auth/postLoginService.test.js

@@ -23,7 +23,7 @@ import PostLoginService from "./postLoginService";
 import StartLoopAuthSessionCheckService from "./startLoopAuthSessionCheckService";
 import InformCallToActionPagemod from "../../pagemod/informCallToActionPagemod";
 import toolbarService from "../toolbar/toolbarService";
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
+import SiteSettingsRuntimeCache from "../siteSettings/siteSettingsRuntimeCache";
 
 beforeEach(async () => {
   jest.clearAllMocks();
@@ -49,7 +49,7 @@ describe("PostLoginService", () => {
       jest.spyOn(informCtaPortWrapper, "emit");
       jest.spyOn(toolbarService, "handleUserLoggedIn").mockImplementation(async () => {});
       jest.spyOn(StartLoopAuthSessionCheckService, "exec").mockImplementation(async () => {});
-      jest.spyOn(OrganizationSettingsModel, "flushCache");
+      jest.spyOn(SiteSettingsRuntimeCache, "flushAll");
 
       // execution
       await PostLoginService.exec();
@@ -62,8 +62,8 @@ describe("PostLoginService", () => {
       expect(BrowserTabService.sendMessage).toHaveBeenCalledWith(workerCta, "passbolt.port.connect", workerCta.id);
       expect(informCtaPortWrapper.emit).toHaveBeenCalledWith("passbolt.auth.after-login");
       expect(informCtaPortWrapper.emit).toHaveBeenCalledTimes(1);
-      // The organization setting cache has been flushed
-      expect(OrganizationSettingsModel.flushCache).toHaveBeenCalledTimes(1);
+      // The site settings runtime cache has been flushed
+      expect(SiteSettingsRuntimeCache.flushAll).toHaveBeenCalledTimes(1);
     });
 
     it("Should not send messages if no workers needs to receive post logout event", async () => {

package/src/all/background_page/service/auth/startLoopAuthSessionCheckService.js

@@ -13,6 +13,8 @@
  */
 import CheckAuthStatusService from "./checkAuthStatusService";
 import PostLogoutService from "./postLogoutService";
+import GetActiveAccountService from "../account/getActiveAccountService";
+import BuildApiClientOptionsService from "../account/buildApiClientOptionsService";
 
 const CHECK_IS_AUTHENTICATED_INTERVAL_PERIOD = 60000;
 const AUTH_SESSION_CHECK_ALARM = "AuthSessionCheck";
@@ -50,7 +52,9 @@ class StartLoopAuthSessionCheckService {
     if (alarm.name !== StartLoopAuthSessionCheckService.ALARM_NAME) {
       return;
     }
-    const checkAuthService = new CheckAuthStatusService();
+    const account = await GetActiveAccountService.get();
+    const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+    const checkAuthService = new CheckAuthStatusService(account, apiClientOptions);
     const authStatus = await checkAuthService.checkAuthStatus(true);
     if (!authStatus.isAuthenticated) {
       PostLogoutService.exec();

package/src/all/background_page/service/auth/startLoopAuthSessionCheckService.test.js

@@ -14,6 +14,10 @@
 import CheckAuthStatusService from "./checkAuthStatusService";
 import PostLogoutService from "./postLogoutService";
 import StartLoopAuthSessionCheckService from "./startLoopAuthSessionCheckService";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import GetActiveAccountService from "../account/getActiveAccountService";
+import OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
 
 jest.useFakeTimers();
 
@@ -23,6 +27,8 @@ beforeEach(async () => {
   jest.clearAllMocks();
   jest.clearAllTimers();
   await browser.alarms.clearAll();
+  const account = new AccountEntity(defaultAccountDto());
+  jest.spyOn(GetActiveAccountService, "get").mockImplementation(() => account);
 });
 
 describe("StartLoopAuthSessionCheckService", () => {
@@ -30,10 +36,10 @@ describe("StartLoopAuthSessionCheckService", () => {
     expect.assertions(7);
     // Function mocked
     const spyClearAuthSessionCheck = jest.spyOn(StartLoopAuthSessionCheckService, "clearAlarm");
-    const authStatus = { isAuthenticated: true, isMfaRequired: false };
+    const sessionEntity = new OnlineSessionEntity({ is_authenticated: true, is_mfa_authenticated: true });
     const spyIsAuthenticated = jest
       .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-      .mockImplementation(() => Promise.resolve(authStatus));
+      .mockImplementation(() => Promise.resolve(sessionEntity));
 
     //mocking top-level alarm handler
     browser.alarms.onAlarm.addListener(
@@ -42,15 +48,15 @@ describe("StartLoopAuthSessionCheckService", () => {
 
     // Process
     await StartLoopAuthSessionCheckService.exec();
-
     // Expectation
     expect(spyIsAuthenticated).toHaveBeenCalledTimes(0);
     expect(spyClearAuthSessionCheck).toHaveBeenCalledTimes(0);
-    jest.advanceTimersByTime(60000);
+    await jest.advanceTimersByTime(60000);
     expect(spyIsAuthenticated).toHaveBeenCalledTimes(1);
     expect(spyClearAuthSessionCheck).toHaveBeenCalledTimes(0);
 
-    jest.advanceTimersByTime(60000);
+    await jest.advanceTimersByTime(60000);
+
     expect(spyIsAuthenticated).toHaveBeenCalledTimes(2);
 
     await PostLogoutService.exec();
@@ -62,10 +68,10 @@ describe("StartLoopAuthSessionCheckService", () => {
     expect.assertions(4);
     // Function mocked
     const spyClearAuthSessionCheck = jest.spyOn(StartLoopAuthSessionCheckService, "clearAlarm");
-    const authStatus = { isAuthenticated: false, isMfaRequired: false };
+    const sessionEntity = new OnlineSessionEntity({ is_authenticated: false, is_mfa_authenticated: true });
     const spyIsAuthenticated = jest
       .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
-      .mockImplementation(() => Promise.resolve(authStatus));
+      .mockImplementation(() => Promise.resolve(sessionEntity));
     const spyOnPostLogout = jest.spyOn(PostLogoutService, "exec").mockImplementation(async () => {});
 
     //mocking top-level alarm handler
@@ -79,7 +85,7 @@ describe("StartLoopAuthSessionCheckService", () => {
     expect(spyIsAuthenticated).toHaveBeenCalledTimes(0);
     expect(spyClearAuthSessionCheck).toHaveBeenCalledTimes(0);
 
-    jest.advanceTimersByTime(60000);
+    await jest.advanceTimersByTime(60000);
     await Promise.resolve();
 
     expect(spyIsAuthenticated).toHaveBeenCalledTimes(1);

package/src/all/background_page/service/authenticationStatusService.js

@@ -13,22 +13,27 @@
  */
 import MfaAuthenticationRequiredError from "../error/mfaAuthenticationRequiredError";
 import NotFoundError from "../error/notFoundError";
-import { ApiClient } from "passbolt-styleguide/src/shared/lib/apiClient/apiClient";
 import PassboltBadResponseError from "../error/passboltBadResponseError";
-import GetActiveAccountService from "./account/getActiveAccountService";
-import BuildApiClientOptionsService from "./account/buildApiClientOptionsService";
+import AbstractService from "passbolt-styleguide/src/shared/services/api/abstract/abstractService";
 
 const AUTH_RESOURCE_NAME = "/auth";
 const MFA_VERIFY_ERROR_REGEXP = /mfa\/verify\/error\.json$/;
 
-class AuthenticationStatusService {
+class AuthenticationStatusService extends AbstractService {
+  /**
+   * @constructor
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    super(apiClientOptions, AUTH_RESOURCE_NAME);
+  }
   /**
    * Check if the current user is authenticated.
    * @returns {Promise<boolean>}
    */
-  static async isAuthenticated() {
-    const apiClient = new ApiClient(await this.getApiClientOptions());
-    const url = apiClient.buildUrl(`${apiClient.baseUrl.toString()}/is-authenticated`, null);
+  async isAuthenticated() {
+    const url = this.apiClient.buildUrl(`${this.apiClient.baseUrl.toString()}/is-authenticated`, null);
 
     const fetchOptions = {
       credentials: "include",
@@ -37,7 +42,7 @@ class AuthenticationStatusService {
         "content-type": "application/json",
       },
     };
-    const response = await apiClient.sendRequest("GET", url, null, fetchOptions);
+    const response = await this.apiClient.sendRequest("GET", url, null, fetchOptions);
 
     let responseJson;
     try {
@@ -64,16 +69,6 @@ class AuthenticationStatusService {
 
     return false;
   }
-
-  /**
-   * Return a built ApiClientOptions for requesting the API.
-   * @returns {ApiClientOptions}
-   * @private
-   */
-  static async getApiClientOptions() {
-    const account = await GetActiveAccountService.get();
-    return BuildApiClientOptionsService.buildFromAccount(account).setResourceName(AUTH_RESOURCE_NAME);
-  }
 }
 
 export default AuthenticationStatusService;

package/src/all/background_page/service/authenticationStatusService.test.js

@@ -15,7 +15,7 @@ import AuthenticationStatusService from "./authenticationStatusService";
 import { enableFetchMocks } from "jest-fetch-mock";
 import { mockApiResponse, mockApiResponseError, mockApiRedirectResponse } from "../../../../test/mocks/mockApiResponse";
 import NotFoundError from "../error/notFoundError";
-import MockExtension from "../../../../test/mocks/mockExtension";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
 import MfaAuthenticationRequiredError from "../error/mfaAuthenticationRequiredError";
 
 beforeAll(() => {
@@ -24,7 +24,6 @@ beforeAll(() => {
 
 beforeEach(async () => {
   jest.clearAllMocks();
-  await MockExtension.withConfiguredAccount();
 });
 
 describe("AuthenticationStatusService::isAuthenticated", () => {
@@ -35,24 +34,28 @@ describe("AuthenticationStatusService::isAuthenticated", () => {
   it("should return true if the user is fully authenticated", async () => {
     expect.assertions(1);
     mockIsAuthenticated(() => mockApiResponse({}));
-    await expect(AuthenticationStatusService.isAuthenticated()).resolves.toStrictEqual(true);
+    const authenticationStatusService = new AuthenticationStatusService(defaultApiClientOptions());
+    await expect(authenticationStatusService.isAuthenticated()).resolves.toStrictEqual(true);
   });
 
   it("should return false if the user is not signed in and doesn't required MFA", async () => {
     expect.assertions(1);
     mockIsAuthenticated(() => mockApiResponseError(403, "User is not signed in"));
-    await expect(AuthenticationStatusService.isAuthenticated()).resolves.toStrictEqual(false);
+    const authenticationStatusService = new AuthenticationStatusService(defaultApiClientOptions());
+    await expect(authenticationStatusService.isAuthenticated()).resolves.toStrictEqual(false);
   });
 
   it("should throw an Error if the endpoint is not found", async () => {
     expect.assertions(1);
     mockIsAuthenticated(() => mockApiResponseError(404, "Endpoint is not found"));
-    await expect(AuthenticationStatusService.isAuthenticated()).rejects.toThrow(NotFoundError);
+    const authenticationStatusService = new AuthenticationStatusService(defaultApiClientOptions());
+    await expect(authenticationStatusService.isAuthenticated()).rejects.toThrow(NotFoundError);
   });
 
   it("should throw an MfaAuthenticationRequiredError if the user miss the Mfa authentication", async () => {
     expect.assertions(1);
     mockIsAuthenticated(() => mockApiRedirectResponse("/mfa/verify/error.json"));
-    await expect(AuthenticationStatusService.isAuthenticated()).rejects.toThrow(MfaAuthenticationRequiredError);
+    const authenticationStatusService = new AuthenticationStatusService(defaultApiClientOptions());
+    await expect(authenticationStatusService.isAuthenticated()).rejects.toThrow(MfaAuthenticationRequiredError);
   });
 });

package/src/all/background_page/service/crypto/generateGpgKeyPairService.test.js

@@ -17,9 +17,9 @@ import GenerateGpgKeyPairOptionsEntity from "../../model/entity/gpgkey/generate/
 import DecryptPrivateKeyService from "../../service/crypto/decryptPrivateKeyService";
 import { OpenpgpAssertion } from "../../utils/openpgp/openpgpAssertions";
 import { defaultDto } from "../../model/entity/gpgkey/generate/generateGpgKeyPairOptionsEntity.test.data";
-import { customEmailValidationProOrganizationSettings } from "../../model/entity/organizationSettings/organizationSettingsEntity.test.data";
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
-import OrganizationSettingsEntity from "../../model/entity/organizationSettings/organizationSettingsEntity";
+import { customEmailValidationProSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import SiteSettingsRuntimeCache from "../siteSettings/siteSettingsRuntimeCache";
 
 describe("GenerateGpgKeyPair service", () => {
   it(
@@ -124,8 +124,8 @@ describe("GenerateGpgKeyPair service", () => {
   it(
     "should generate a key pair with a non standard email if the application settings customize the email validation.",
     async () => {
-      const organizationSettings = customEmailValidationProOrganizationSettings();
-      OrganizationSettingsModel.set(new OrganizationSettingsEntity(organizationSettings));
+      const organizationSettings = customEmailValidationProSiteSettings();
+      SiteSettingsRuntimeCache.set(new SiteSettingsEntity(organizationSettings));
 
       const generateGpgKeyPairOptionsDto = defaultDto({ email: "admin@passbolt.c" });
       const generateGpgKeyPairOptionsEntity = new GenerateGpgKeyPairOptionsEntity(generateGpgKeyPairOptionsDto);

package/src/all/background_page/service/crypto/getGpgKeyCreationDateService.js

@@ -11,28 +11,29 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.6.3
  */
-import OrganizationSettingsModel from "../../model/organizationSettings/organizationSettingsModel";
+import GetOrFindSiteSettingsService from "../siteSettings/getOrFindSiteSettingsService";
 
 class GetGpgKeyCreationDateService {
   /**
    * Returns a date that could be used to generate a gpg key
    * while being compatible with both the client and the server.
    *
+   * @param {AccountEntity} account The account.
    * @param {ApiClientOptions} apiClientOptions The api client options.
    * @return {Promise<integer>}
    */
-  static async getDate(apiClientOptions) {
-    const organizationSettingsModel = new OrganizationSettingsModel(apiClientOptions);
+  static async getDate(account, apiClientOptions) {
+    const getOrFindSiteSettingsService = new GetOrFindSiteSettingsService(account, apiClientOptions);
 
-    let organizationSettings;
+    let siteSettings;
     try {
-      organizationSettings = await organizationSettingsModel.getOrFind();
+      siteSettings = await getOrFindSiteSettingsService.getOrFind(false);
     } catch (e) {
       console.error(e);
       return new Date().getTime();
     }
 
-    return organizationSettings.isServerInPast() ? organizationSettings.serverTime : new Date().getTime();
+    return siteSettings.isServerInPast() ? siteSettings.serverTime : new Date().getTime();
   }
 }
 

package/src/all/background_page/service/crypto/getGpgKeyCreationDateService.test.js

@@ -12,16 +12,19 @@
  * @since         3.6.0
  */
 import GetGpgKeyCreationDateService from "./getGpgKeyCreationDateService";
-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 MockExtension from "../../../../../test/mocks/mockExtension";
 import { enableFetchMocks } from "jest-fetch-mock";
 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";
 
-let currentTime;
+let currentTime, account;
 beforeEach(() => {
   enableFetchMocks();
   MockExtension.withMissingPrivateKeyAccount();
+  account = new AccountEntity(defaultAccountDto());
 
   jest.useFakeTimers();
   currentTime = new Date();
@@ -34,9 +37,9 @@ describe("GetGpgCompatibleDate service", () => {
     const serverTimestamp = currentTime.getTime() - 3600000; //current time minus one hour
     const serverTime = new Date(serverTimestamp);
 
-    fetch.doMock(() => mockApiResponse(anonymousOrganizationSettings(), { servertime: serverTime.getTime() / 1000 }));
+    fetch.doMock(() => mockApiResponse(anonymousSiteSettings(), { servertime: serverTime.getTime() / 1000 }));
 
-    const gpgDate = await GetGpgKeyCreationDateService.getDate(defaultApiClientOptions());
+    const gpgDate = await GetGpgKeyCreationDateService.getDate(account, defaultApiClientOptions());
     expect(gpgDate).toEqual(serverTime.getTime());
   });
 
@@ -44,9 +47,9 @@ describe("GetGpgCompatibleDate service", () => {
     const serverTimestamp = currentTime.getTime() + 3600000; //current time plus one hour
     const serverTime = new Date(serverTimestamp);
 
-    fetch.doMock(() => mockApiResponse(anonymousOrganizationSettings(), { servertime: serverTime.getTime() / 1000 }));
+    fetch.doMock(() => mockApiResponse(anonymousSiteSettings(), { servertime: serverTime.getTime() / 1000 }));
 
-    const gpgDate = await GetGpgKeyCreationDateService.getDate(defaultApiClientOptions());
+    const gpgDate = await GetGpgKeyCreationDateService.getDate(account, defaultApiClientOptions());
     expect(gpgDate).toEqual(currentTime.getTime());
   });
 
@@ -55,7 +58,7 @@ describe("GetGpgCompatibleDate service", () => {
       throw new Error("Something wrong happened");
     });
 
-    const gpgDate = await GetGpgKeyCreationDateService.getDate(defaultApiClientOptions());
+    const gpgDate = await GetGpgKeyCreationDateService.getDate(account, defaultApiClientOptions());
     expect(gpgDate).toEqual(currentTime.getTime());
   });
 });