passbolt-styleguide 3.5.2 → 3.6.0-alpha2

package/src/react-extension/contexts/Authentication/AuthenticationSetupContext.test.js

@@ -0,0 +1,364 @@
+/**
+ * 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 mockComponentSetState from "../../test/mock/components/React/mockSetState";
+import {mockUserAgent} from "jest-useragent-mock";
+import {AuthenticationSetupContextProvider, AuthenticationSetupWorkflowStates} from "./AuthenticationSetupContext";
+import {defaultProps, withAccountRecoveryEnabled} from "./AuthenticationSetupContext.test.data";
+import GpgKeyError from "../../lib/Error/GpgKeyError";
+import InvalidMasterPasswordError from "../../lib/Error/InvalidMasterPasswordError";
+
+beforeEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+
+describe("AuthenticationSetupContextProvider", () => {
+  describe("AuthenticationSetupContextProvider::constructor", () => {
+    it("The machine state should be by default set to: LOADING", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.LOADING);
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::initialize", () => {
+    it("When the extension was just installed and the browser is Chrome, the machine state should be set to: INTRODUCE_EXTENSION", async() => {
+      mockUserAgent('chrome');
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.is-first-install", jest.fn(() => Promise.resolve(true)));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.setup.is-first-install"]).toHaveBeenCalled();
+      expect(props.context.port.requestListeners["passbolt.setup.start"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.INTRODUCE_EXTENSION);
+    });
+
+    it("When the extension was just installed and the browser is Firefox, the machine state should be set to: GENERATE_GPG_KEY", async() => {
+      mockUserAgent('firefox');
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.is-first-install", jest.fn(() => Promise.resolve(true)));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.setup.is-first-install"]).toHaveBeenCalled();
+      expect(props.context.port.requestListeners["passbolt.setup.start"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.GENERATE_GPG_KEY);
+    });
+
+    it("When the extension was already installed and the browser is Chrome, the machine state should be set to: GENERATE_GPG_KEY", async() => {
+      mockUserAgent('chrome');
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.setup.is-first-install"]).toHaveBeenCalled();
+      expect(props.context.port.requestListeners["passbolt.setup.start"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.GENERATE_GPG_KEY);
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::goToGenerateGpgKey", () => {
+    it("When the go to succeed, the machine state should be set to: GENERATE_GPG_KEY", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      await contextProvider.initialize();
+      await contextProvider.goToGenerateGpgKey();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.GENERATE_GPG_KEY);
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::generateGpgKey", () => {
+    it("When the gpg key is created, the machine state should be set to: DOWNLOAD_RECOVERY_KIT", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.generateGpgKey("passphrase");
+      expect(props.context.port.requestListeners["passbolt.setup.generate-key"]).toHaveBeenCalledWith({passphrase: "passphrase"}, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.DOWNLOAD_RECOVERY_KIT);
+    });
+
+    it("When an error occurred during the gpg key creation, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.generate-key", jest.fn(() => Promise.reject(new Error('Unexpected error'))));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.generateGpgKey("passphrase");
+      expect(props.context.port.requestListeners["passbolt.setup.generate-key"]).toHaveBeenCalledWith({passphrase: "passphrase"}, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::downloadRecoveryKit", () => {
+    it("The the recovery kit is downloaded with success, the machine state should remain set to the state it was before the operation", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      const expectedWorkflowState = contextProvider.state.state;
+      await contextProvider.downloadRecoveryKit();
+      expect(props.context.port.requestListeners["passbolt.setup.download-recovery-kit"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(expectedWorkflowState);
+    });
+
+    it("When an error occurred during the recovery kit download, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.download-recovery-kit", jest.fn(() => Promise.reject(new Error('Unexpected error'))));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.downloadRecoveryKit();
+      expect(props.context.port.requestListeners["passbolt.setup.download-recovery-kit"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::downloadRecoveryKit", () => {
+    it("Given the account recovery policy is not set or disabled and the the recovery kit is downloaded, the machine state should be set to: CHOOSE_SECURITY_TOKEN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      await contextProvider.initialize();
+      await contextProvider.handleRecoveryKitDownloaded();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.CHOOSE_SECURITY_TOKEN);
+    });
+
+    it("Given the account recovery is enabled and the the recovery kit is downloaded, the machine state should be set to: CHOOSE_ACCOUNT_RECOVERY_PREFERENCE", async() => {
+      const props = withAccountRecoveryEnabled(defaultProps());
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      await contextProvider.initialize();
+      await contextProvider.handleRecoveryKitDownloaded();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.CHOOSE_ACCOUNT_RECOVERY_PREFERENCE);
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::goToImportGpgKey", () => {
+    it("When the go to succeed, the machine state should be set to: IMPORT_GPG_KEY", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      await contextProvider.initialize();
+      await contextProvider.goToImportGpgKey();
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.IMPORT_GPG_KEY);
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::importGpgKey", () => {
+    it("When the gpg key is imported with success, the machine state should be set to: VALIDATE_PASSPHRASE", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.importGpgKey("armored_key");
+      expect(props.context.port.requestListeners["passbolt.setup.import-key"]).toHaveBeenCalledWith("armored_key", undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.VALIDATE_PASSPHRASE);
+    });
+
+    it("When an invalid gpg key fails the import, the error should be rethrown and the machine state should remain on: IMPORT_GPG_KEY", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.import-key", jest.fn(() => Promise.reject(new GpgKeyError())));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.goToImportGpgKey();
+      try {
+        await contextProvider.importGpgKey("armored_key");
+        expect(false).toBeTruthy();
+      } catch (error) {
+        expect(props.context.port.requestListeners["passbolt.setup.import-key"]).toHaveBeenCalledWith("armored_key", undefined);
+        expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.IMPORT_GPG_KEY);
+        expect(error.name).toEqual("GpgKeyError");
+      }
+    });
+
+    it("When an error occurred during the gpg key import, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.import-key", jest.fn(() => Promise.reject(new Error('Unexpected error'))));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.importGpgKey("armored_key");
+      expect(props.context.port.requestListeners["passbolt.setup.import-key"]).toHaveBeenCalledWith("armored_key", undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::checkPassphrase", () => {
+    it("When a passphrase check succeed the machine state should be set to: CHOOSE_SECURITY_TOKEN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.importGpgKey();
+      await contextProvider.checkPassphrase("passphrase");
+      expect(props.context.port.requestListeners["passbolt.setup.verify-passphrase"]).toHaveBeenCalledWith("passphrase", false, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.CHOOSE_SECURITY_TOKEN);
+    });
+
+    it("When a passphrase check succeed and account recovery policy is enabled the machine state should be set to: CHOOSE_ACCOUNT_RECOVERY_PREFERENCE", async() => {
+      const props = withAccountRecoveryEnabled(defaultProps());
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.importGpgKey();
+      await contextProvider.checkPassphrase("passphrase");
+      expect(props.context.port.requestListeners["passbolt.setup.verify-passphrase"]).toHaveBeenCalledWith("passphrase", false, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.CHOOSE_ACCOUNT_RECOVERY_PREFERENCE);
+    });
+
+    it("When a passphrase check succeed and accountRecovery feature flag is disabled but the server sends an enabled account recovery organization policy, the machine state should be set to: CHOOSE_SECURITY_TOKEN", async() => {
+      const props = withAccountRecoveryEnabled(defaultProps());
+      props.context.siteSettings.canIUse = jest.fn(() => false);
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.importGpgKey();
+      await contextProvider.checkPassphrase("passphrase");
+      expect(props.context.port.requestListeners["passbolt.setup.verify-passphrase"]).toHaveBeenCalledWith("passphrase", false, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.CHOOSE_SECURITY_TOKEN);
+    });
+
+    it("When a wrong passphrase is requested to be checked, the error should be rethrown and the machine state should remain on: SIGN_IN", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.verify-passphrase", jest.fn(() => Promise.reject(new InvalidMasterPasswordError())));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.importGpgKey();
+      try {
+        await contextProvider.checkPassphrase("passphrase");
+        expect(false).toBeTruthy();
+      } catch (error) {
+        expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.VALIDATE_PASSPHRASE);
+        expect(error.name).toEqual("InvalidMasterPasswordError");
+      }
+    });
+
+    it("If an unexpected error occurred the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.verify-passphrase", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.checkPassphrase("passphrase");
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::chooseAccountRecoveryPreference", () => {
+    it("When the account recovery preferences are set with success, the machine state should be set to: CHOOSE_SECURITY_TOKEN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.chooseAccountRecoveryPreference("approved");
+      expect(props.context.port.requestListeners["passbolt.setup.set-account-recovery-user-setting"]).toHaveBeenCalledWith("approved", null, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.CHOOSE_SECURITY_TOKEN);
+    });
+
+    it("When the account recovery preferences fails, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.set-account-recovery-user-setting", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.chooseAccountRecoveryPreference("approved");
+      expect(props.context.port.requestListeners["passbolt.setup.set-account-recovery-user-setting"]).toHaveBeenCalledWith("approved", null, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationSetupContextProvider::chooseSecurityToken", () => {
+    it("When the security token preferences are set with success, the machine state should be set to: SIGNING_IN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.chooseSecurityToken({color: "black", textColor: "red"});
+      expect(props.context.port.requestListeners["passbolt.setup.set-security-token"]).toHaveBeenCalledWith({color: "black", textColor: "red"}, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.SIGNING_IN);
+    });
+
+    it("When the security token preferences cannot be set, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.setup.set-security-token", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationSetupContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.chooseSecurityToken({color: "black", textColor: "red"});
+      expect(props.context.port.requestListeners["passbolt.setup.set-security-token"]).toHaveBeenCalledWith({color: "black", textColor: "red"}, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationSetupWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+});

package/src/react-extension/contexts/DialogContext.test.data.js

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+
+/**
+ * Default context
+ * @param {Object} context The override
+ * @returns {object}
+ */
+export function defaultDialogContext(context = {}) {
+  const defaultContext = {
+    dialogs: [],
+    open: jest.fn(),
+    close: jest.fn()
+  };
+  return Object.assign(defaultContext, context);
+}

package/src/react-extension/contexts/ExtAppContext.js

@@ -134,12 +134,6 @@ class ExtAppContextProvider extends React.Component {
       // progress dialog
       progressDialogProps: {},
 
-      // error dialog
-      errorDialogProps: {
-        title: null,
-        message: null
-      },
-
       // Resource comment dialog
       resourceCommentId: null, // Selected resource comment id
       mustRefreshComments: false, // Flag telling whether the current list of comments should be refreshed

package/src/react-extension/contexts/ExtAppContext.test.data.js

@@ -0,0 +1,50 @@
+/**
+ * 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 UserSettings from "../../shared/lib/Settings/UserSettings";
+import userSettingsFixture from "../test/fixture/Settings/userSettings";
+import SiteSettings from "../../shared/lib/Settings/SiteSettings";
+import siteSettingsFixture from "../test/fixture/Settings/siteSettings";
+import ResourceTypesSettings from "../../shared/lib/Settings/ResourceTypesSettings";
+import resourceTypesFixture from "../test/fixture/ResourceTypes/resourceTypes";
+import MockPort from "../test/mock/MockPort";
+import MockStorage from "../test/mock/MockStorage";
+
+/**
+ * Returns the default app context for the unit test
+ * @param appContext An existing app context
+ * @returns {any | ({userSettings: UserSettings, siteSettings: SiteSettings, port: MockPort} & {})}
+ */
+
+export function defaultAppContext(appContext) {
+  const userSettings = new UserSettings(userSettingsFixture);
+  const siteSettings = new SiteSettings(siteSettingsFixture);
+  const resourceTypesSettings = new ResourceTypesSettings(siteSettings, resourceTypesFixture);
+  const defaultAppContext = {
+    locale: 'en-UK',
+    userSettings,
+    siteSettings,
+    resourceTypesSettings,
+    port: new MockPort(),
+    storage: new MockStorage(),
+    loggedInUser: {
+      id: userSettings.id,
+      role: {
+        name: 'admin'
+      }
+    },
+    users: [],
+  };
+  return Object.assign(defaultAppContext, appContext || {});
+}

package/src/react-extension/contexts/NavigationContext.js

@@ -31,6 +31,10 @@ export const NavigationContext = React.createContext({
   }, // Whenever the users wants to navigate to the administration workspace email notifications
   onGoToAdministrationSubscriptionRequested: () => {
   }, // Whenever the users wants to navigate to the administration workspace subscription
+  onGoToAdministrationInternationalizationRequested: () => {
+  }, // Whenever the users wants to navigate to the administration workspace internationalization
+  onGoToAdministrationAccountRecoveryRequested: () => {
+  }, // Whenever the users wants to navigate to the administration workspace account recovery
   // Passwords
   onGoToPasswordsRequested: () => {
   }, // Whenever the user wants to navigate to the passwords workspace
@@ -52,6 +56,8 @@ export const NavigationContext = React.createContext({
   }, // Whenever the user wants to navigate to the users settings workspace keys section.
   onGoToUserSettingsMobileRequested: () => {
   }, // Whenever the user wants to navigate to the users settings workspace mobile section.
+  onGoToUserSettingsAccountRecoveryRequested: () => {
+  }, // Whenever the user wants to navigate to the users settings workspace mobile section.
   onGoToNewTab: () => {
   }, // Whenever the user want to navigate to a new url.
 });
@@ -82,7 +88,8 @@ class NavigationContextProvider extends React.Component {
       onGoToAdministrationUsersDirectoryRequested: this.onGoToAdministrationUsersDirectoryRequested.bind(this), // Whenever the user wants to navigate to the administration workspace users directory
       onGoToAdministrationEmailNotificationsRequested: this.onGoToAdministrationEmailNotificationsRequested.bind(this), // Whenever the user wants to navigate to the administration workspace email notifications
       onGoToAdministrationSubscriptionRequested: this.onGoToAdministrationSubscriptionRequested.bind(this), // Whenever the user wants to navigate to the administration workspace subscription
-      onGoToAdministrationInternationalizationRequested: this.onGoToAdministrationInternationalizationRequested.bind(this), // Whenever the user wants to navigate to the administration workspace subscription
+      onGoToAdministrationInternationalizationRequested: this.onGoToAdministrationInternationalizationRequested.bind(this), // Whenever the user wants to navigate to the administration workspace internationalization
+      onGoToAdministrationAccountRecoveryRequested: this.onGoToAdministrationAccountRecoveryRequested.bind(this), // Whenever the user wants to navigate to the administration workspace account recovery
       // Passwords
       onGoToPasswordsRequested: this.onGoToPasswordsRequested.bind(this), // Whenever the user wants to navigate to the passwords workspace
       // Users
@@ -95,6 +102,7 @@ class NavigationContextProvider extends React.Component {
       onGoToUserSettingsMfaRequested: this.onGoToUserSettingsMfaRequested.bind(this), // Whenever the user wants to navigate to the users settings workspace mfa section.
       onGoToUserSettingsKeysRequested: this.onGoToUserSettingsKeysRequested.bind(this), // Whenever the user wants to navigate to the users settings workspace keys section.
       onGoToUserSettingsMobileRequested: this.onGoToUserSettingsMobileRequested.bind(this), // Whenever the user wants to navigate to the users settings workspace mobile section.
+      onGoToUserSettingsAccountRecoveryRequested: this.onGoToUserSettingsAccountRecoveryRequested.bind(this), // Whenever the user wants to navigate to the users settings workspace account recovery section.
     };
   }
 
@@ -182,6 +190,14 @@ class NavigationContextProvider extends React.Component {
     await this.goTo("api", "/app/administration/internationalization");
   }
 
+  /**
+   * Whenever the user wants to navigate to the administration workspace account recovery.
+   * @returns {Promise<void>}
+   */
+  async onGoToAdministrationAccountRecoveryRequested() {
+    await this.goTo("browser-extension", "/app/administration/account-recovery");
+  }
+
   /**
    * Returns true if the user has the MFA capability
    * @returns {boolean}
@@ -283,13 +299,21 @@ class NavigationContextProvider extends React.Component {
   }
 
   /**
-   * Whenever the user wants to navigate to the users settings workspace keys section.
+   * Whenever the user wants to navigate to the users settings workspace mobile section.
    * @returns {Promise<void>}
    */
   async onGoToUserSettingsMobileRequested() {
     await this.goTo("browser-extension", "/app/settings/mobile");
   }
 
+  /**
+   * Whenever the user wants to navigate to the users settings workspace account recovery section.
+   * @returns {Promise<void>}
+   */
+  async onGoToUserSettingsAccountRecoveryRequested() {
+    await this.goTo("browser-extension", "/app/settings/account-recovery");
+  }
+
   /**
    * Render the component
    * @returns {JSX}

package/src/react-extension/contexts/ResourceWorkspaceContext.js

@@ -20,6 +20,7 @@ import {withActionFeedback} from "./ActionFeedbackContext";
 import {withLoading} from "./LoadingContext";
 import sanitizeUrl, {urlProtocols} from "../lib/Sanitize/sanitizeUrl";
 import {DateTime} from "luxon";
+import debounce from "debounce-promise";
 
 /**
  * Context related to resources ( filter, current selections, etc.)
@@ -87,6 +88,12 @@ export class ResourceWorkspaceContextProvider extends React.Component {
     super(props);
     this.state = this.defaultState;
     this.initializeProperties();
+
+    /*
+     * Execute first request to refresh users, groups, etc. then wait 10sec to trigger next one
+     * E.g. Only perform two populate max per 10 sec
+     */
+    this.populateDebounced = debounce(this.populate, 10000, {leading: true, accumulate: false});
   }
 
   /**
@@ -152,7 +159,7 @@ export class ResourceWorkspaceContextProvider extends React.Component {
    * Whenever the component is mounted
    */
   async componentDidMount() {
-    this.populate();
+    this.populateDebounced();
     this.handleResourcesWaitedFor();
   }
 
@@ -178,8 +185,8 @@ export class ResourceWorkspaceContextProvider extends React.Component {
       // Avoid a side-effect whenever one inputs a specific resource url (it unselect the resource otherwise )
       const isNotNonePreviousFilter = previousFilter.type !== ResourceWorkspaceFilterTypes.NONE;
       if (isNotNonePreviousFilter) {
-        await this.populate();
         await this.unselectAll();
+        await this.populateDebounced();
       }
     }
   }

package/src/react-extension/contexts/ResourceWorkspaceContext.test.page.js

@@ -78,10 +78,19 @@ export default class ResourceWorkspaceContextPage {
    * @ linkCssSelector The CSS link selector
    */
   async goToLink(linkCssSelector) {
+    const oldFilter = this.filter;
     const element = this._page.container.querySelector(linkCssSelector);
     const leftClick = {button: 0};
     fireEvent.click(element, leftClick);
-    await waitFor(() => {});
+    /*
+     * We ensure that the filter is applied properly before ending the promise.
+     * Without that, some unit tests may fail because they don't have the right context to run.
+     */
+    await waitFor(() => {
+      if (oldFilter === this.filter) {
+        throw new Error("Context didn't change yet.");
+      }
+    });
   }
 
   /**

package/src/react-extension/contexts/UserSettingsContext.js

@@ -46,7 +46,7 @@ export class UserSettingsContextProvider extends React.Component {
    */
   constructor(props) {
     super(props);
-    this.state = Object.assign(this.defaultState, props.value);
+    this.state = this.defaultState;
   }
 
   /**
@@ -144,7 +144,6 @@ export class UserSettingsContextProvider extends React.Component {
 
 UserSettingsContextProvider.propTypes = {
   context: PropTypes.any, // The application context
-  value: PropTypes.any, // The initial value of the context
   children: PropTypes.any // The children components
 };
 export default withAppContext(UserSettingsContextProvider);