passbolt-styleguide 3.5.2 → 3.6.0-alpha2

package/src/react-extension/contexts/Authentication/AuthenticationAccountRecoveryContext.js

@@ -0,0 +1,282 @@
+/**
+ * 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 React from "react";
+import PropTypes from "prop-types";
+import {withAppContext} from "../AppContext";
+
+// The authentication account recovery workflow states.
+export const AuthenticationAccountRecoveryWorkflowStates = {
+  VERIFY_PASSPHRASE: "Validate Passphrase",
+  RECOVERING_ACCOUNT: "Recovering Account",
+  SIGNING_IN: 'Signing in',
+  DOWNLOAD_RECOVERY_KIT: 'Downloading Recovery Kit',
+  LOADING: "Loading",
+  UNEXPECTED_ERROR: "Unexpected Error",
+  HELP_CREDENTIALS_LOST: "Help Credentials lost",
+  CHECK_MAILBOX: "Check mailbox",
+};
+
+/**
+ * The authentication account recovery context.
+ * Handle the business logic of the account recovery and the associated workflow
+ * @type {React.Context<Object>}
+ */
+export const AuthenticationAccountRecoveryContext = React.createContext({
+  // Workflow data.
+  state: null, // The recover workflow current state
+  error: null, // The current error
+
+  // Workflow mutators.
+  verifyPassphrase: () => {
+  }, // Verify the user wants to check the account recovery temporary gpgkey passphrase
+  complete: () => {
+  }, // Complete the account recovery
+  needHelpCredentialsLost: () => {
+  }, // Whenever the user lost its passphrase.
+  goToValidatePassphrase: () => {
+  }, // Whenever the user wants to go to the validate passphrase.
+  requestHelpCredentialsLost: () => {
+  }, // Whenever the user wants to request help because it lost its credentials.
+  downloadRecoveryKit: () => {
+  }, // Go to the download recovery kit step
+  handleRecoveryKitDownloaded: () => {
+  }, // Go to the step after the download recovery kit
+});
+
+/**
+ * The authentication recover context provider.
+ * Handle the business logic of the recover and the associated workflow.
+ */
+export class AuthenticationAccountRecoveryContextProvider extends React.Component {
+  /**
+   * Default constructor
+   * @param props The component props
+   */
+  constructor(props) {
+    super(props);
+    this.state = this.defaultState;
+
+    //This is not on state as it's not related to rendering
+    this.passphrase = null;
+    this.rememberMe = null;
+  }
+
+  /**
+   * Returns the default component state
+   */
+  get defaultState() {
+    return {
+      // Workflow data.
+      state: AuthenticationAccountRecoveryWorkflowStates.LOADING, // The account recovery workflow current state
+      error: null, // The current error
+      account: null, // The account recovery associated account.
+
+      // Public workflow mutators.
+      verifyPassphrase: this.verifyPassphrase.bind(this), // Verify the user wants to check the account recovery temporary gpgkey passphrase
+      complete: this.complete.bind(this), // Complete the account recovery request
+      needHelpCredentialsLost: this.needHelpCredentialsLost.bind(this), // Whenever the user lost its passphrase.
+      goToValidatePassphrase: this.goToValidatePassphrase.bind(this), // Whenever the user wants to go to the validate passphrase.
+      requestHelpCredentialsLost: this.requestHelpCredentialsLost.bind(this), // Whenever the user wants to request help because it lost its credentials.
+      downloadRecoveryKit: this.downloadRecoveryKit.bind(this), // Go to the download recovery kit step
+      handleRecoveryKitDownloaded: this.handleRecoveryKitDownloaded.bind(this), // Go to the step after the download recovery kit
+    };
+  }
+
+  /**
+   * Whenever the component is initialized
+   */
+  componentDidMount() {
+    this.initialize();
+  }
+
+  /**
+   * Initialize the authentication account recovery workflow
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (!(await this.verifyCanContinueAccountRecovery())) {
+      return;
+    }
+    await this.goToValidatePassphrase();
+  }
+
+  /**
+   * Verify the user can continue the account recovery process.
+   * @returns {Promise<void>}
+   */
+  async verifyCanContinueAccountRecovery() {
+    try {
+      await this.props.context.port.request("passbolt.account-recovery.continue");
+      return true;
+    } catch (error) {
+      // It shouldn't occur. For any errors at this stage, the background page will destroy the iframe an let the application served by the API take care of it.
+      await this.handleUnexpectedError(error);
+      return false;
+    }
+  }
+
+  /**
+   * Go to the validate account passphrase.
+   * @returns {Promise<void>}
+   */
+  async goToValidatePassphrase() {
+    try {
+      const account = await this.props.context.port.request("passbolt.account-recovery.get-account");
+      await this.setState({state: AuthenticationAccountRecoveryWorkflowStates.VERIFY_PASSPHRASE, account: account});
+    } catch (error) {
+      await this.handleUnexpectedError(error);
+    }
+  }
+
+  /**
+   * Verify the user account recovery temporary gpgkey passphrase.
+   * @param {string} passphrase The passphrase.
+   * @returns {Promise<void>}
+   * @throw {Error} If an expected errors is returned by the background page, rethrow it for the caller component.
+   *  Errors of type: InvalidMasterPasswordError.
+   */
+  async verifyPassphrase(passphrase) {
+    try {
+      await this.props.context.port.request("passbolt.account-recovery.verify-passphrase", passphrase);
+    } catch (error) {
+      if (error.name === "InvalidMasterPasswordError") {
+        throw error;
+      }
+      await this.handleUnexpectedError(error);
+    }
+  }
+
+  /**
+   * Complete the account recovery.
+   * @param {string} passphrase The passphrase.
+   * @param {boolean} rememberMe (Optional) Should the passphrase be remembered? Default false.
+   * @returns {Promise<void>}
+   */
+  async complete(passphrase, rememberMe = false) {
+    await this.setState({state: AuthenticationAccountRecoveryWorkflowStates.RECOVERING_ACCOUNT});
+    try {
+      await this.props.context.port.request("passbolt.account-recovery.recover-account", passphrase);
+      this.passphrase = passphrase;
+      this.rememberMe = rememberMe;
+      this.setState({state: AuthenticationAccountRecoveryWorkflowStates.DOWNLOAD_RECOVERY_KIT});
+    } catch (error) {
+      await this.handleUnexpectedError(error);
+    }
+  }
+
+  /**
+   * Whenever the user wants to download the recovery kit.
+   * @returns {Promise<void>}
+   */
+  async downloadRecoveryKit() {
+    try {
+      await this.props.context.port.request('passbolt.account-recovery.download-recovery-kit');
+    } catch (error) {
+      this.setState({state: AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR, error: error});
+    }
+  }
+
+  /**
+   * Whenever the user finished to download the recovery kit.
+   * @returns {Promise<void>}
+   */
+  async handleRecoveryKitDownloaded() {
+    await this.signIn(this.passphrase, this.rememberMe);
+    this.passphrase = null;
+    this.rememberMe = null;
+  }
+
+  /**
+   * Sign-in.
+   * @param {string} passphrase The passphrase.
+   * @param {boolean} rememberMe (Optional) Should the passphrase be remembered? Default false.
+   * @returns {Promise<void>}
+   */
+  async signIn(passphrase, rememberMe = false) {
+    this.setState({state: AuthenticationAccountRecoveryWorkflowStates.SIGNING_IN});
+    try {
+      await this.props.context.port.request("passbolt.account-recovery.sign-in", passphrase, rememberMe);
+    } catch (error) {
+      await this.handleUnexpectedError(error);
+    }
+  }
+
+  /**
+   * Handle unexpected error.
+   * @param {Object} error The error.
+   * @returns {Promise<void>}
+   */
+  async handleUnexpectedError(error) {
+    await this.setState({state: AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR, error: error});
+  }
+
+  /**
+   * Whenever the user lost its passphrase.
+   * @returns {Promise<void>}
+   */
+  async needHelpCredentialsLost() {
+    await this.setState({state: AuthenticationAccountRecoveryWorkflowStates.HELP_CREDENTIALS_LOST});
+  }
+
+  /**
+   * Whenever the user wants to request help because it lost its credentials.
+   * @returns {Promise<void>}
+   */
+  async requestHelpCredentialsLost() {
+    try {
+      await this.props.context.port.request('passbolt.account-recovery.request-help-credentials-lost');
+      await this.setState({state: AuthenticationAccountRecoveryWorkflowStates.CHECK_MAILBOX});
+    } catch (error) {
+      await this.setState({state: AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR, error: error});
+    }
+  }
+
+  /**
+   * Render the component
+   * @returns {JSX}
+   */
+  render() {
+    return (
+      <AuthenticationAccountRecoveryContext.Provider value={this.state}>
+        {this.props.children}
+      </AuthenticationAccountRecoveryContext.Provider>
+    );
+  }
+}
+
+AuthenticationAccountRecoveryContextProvider.propTypes = {
+  context: PropTypes.any, // The application context
+  children: PropTypes.any // The children components
+};
+export default withAppContext(AuthenticationAccountRecoveryContextProvider);
+
+/**
+ * Authentication account recovery context consumer HOC
+ * @param {React.Component} WrappedComponent The component to wrap
+ */
+export function withAuthenticationAccountRecoveryContext(WrappedComponent) {
+  return class WithAuthenticationContext extends React.Component {
+    render() {
+      return (
+        <AuthenticationAccountRecoveryContext.Consumer>
+          {
+            authenticationAccountRecoveryContext => <WrappedComponent
+              authenticationAccountRecoveryContext={authenticationAccountRecoveryContext} {...this.props} />
+          }
+        </AuthenticationAccountRecoveryContext.Consumer>
+      );
+    }
+  };
+}

package/src/react-extension/contexts/Authentication/AuthenticationAccountRecoveryContext.test.data.js

@@ -0,0 +1,51 @@
+/**
+ * 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 MockPort from "../../test/mock/MockPort";
+import {defaultAppContext} from "../ExtAppContext.test.data";
+
+/**
+ * Default app context for authentication account recovery context.
+ * @param {Object} appContext The context properties override
+ * @return {Object}
+ */
+export function defaultAuthenticationAccountRecoveryAppContext(appContext = {}) {
+  const port = new MockPort();
+  port.addRequestListener("passbolt.account-recovery.continue", jest.fn());
+  port.addRequestListener("passbolt.account-recovery.get-account", jest.fn());
+  port.addRequestListener("passbolt.account-recovery.verify-passphrase", jest.fn());
+  port.addRequestListener("passbolt.account-recovery.recover-account", jest.fn());
+  port.addRequestListener("passbolt.account-recovery.sign-in", jest.fn());
+  port.addRequestListener("passbolt.account-recovery.request-help-credentials-lost", jest.fn());
+  port.addRequestListener("passbolt.account-recovery.download-recovery-kit", jest.fn());
+
+  const defaultAuthenticationRecover = {
+    port: port,
+    onRefreshLocaleRequested: jest.fn(),
+  };
+  return Object.assign(defaultAppContext(defaultAuthenticationRecover), appContext);
+}
+
+/**
+ * Default props.
+ * @param {Object} props The props to override
+ * @returns {object}
+ */
+export function defaultProps(props = {}) {
+  const defaultProps = {
+    context: defaultAuthenticationAccountRecoveryAppContext(props?.context),
+  };
+  delete props.context;
+  return Object.assign(defaultProps, props);
+}

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

@@ -0,0 +1,231 @@
+/**
+ * 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 {
+  AuthenticationAccountRecoveryContextProvider,
+  AuthenticationAccountRecoveryWorkflowStates
+} from "./AuthenticationAccountRecoveryContext";
+import {defaultProps} from "./AuthenticationAccountRecoveryContext.test.data";
+import InvalidMasterPasswordError from "../../lib/Error/InvalidMasterPasswordError";
+
+describe("AuthenticationAccountRecoveryContextProvider", () => {
+  describe("AuthenticationAccountRecoveryContextProvider::constructor", () => {
+    it("The machine state should be by default set to: LOADING", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.LOADING);
+    });
+  });
+
+  describe("AuthenticationAccountRecoveryContextProvider::initialize", () => {
+    it("should redirect the user to the unexpected error page if an uncaught error occurred during the 'can continue' check", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.account-recovery.continue", jest.fn(() => Promise.reject()));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.continue"]).toHaveBeenCalled();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.get-account"]).not.toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR);
+    });
+
+    it("should redirect the user to the unexpected error page if an uncaught error occurred while retrieving the user account.", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.account-recovery.get-account", jest.fn(() => Promise.reject()));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.continue"]).toHaveBeenCalled();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.get-account"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR);
+    });
+
+    it("should redirect the user to the verify passphrase if the user can continue the account recovery process.", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.continue"]).toHaveBeenCalled();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.get-account"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.VERIFY_PASSPHRASE);
+    });
+  });
+
+  describe("AuthenticationAccountRecoveryContextProvider::validatePassphrase", () => {
+    it("When a passphrase check succeed the machine state should remain on VERIFY_PASSPHRASE", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.verifyPassphrase("passphrase");
+      expect(props.context.port.requestListeners["passbolt.account-recovery.verify-passphrase"]).toHaveBeenCalledWith("passphrase", undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.VERIFY_PASSPHRASE);
+    });
+
+    it("When a wrong passphrase is requested to be checked, the error should be rethrown and the machine state should remain on: VERIFY_PASSPHRASE", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.account-recovery.verify-passphrase", jest.fn(() => Promise.reject(new InvalidMasterPasswordError())));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      try {
+        await contextProvider.verifyPassphrase("passphrase");
+        expect(false).toBeTruthy();
+      } catch (error) {
+        expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.VERIFY_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.account-recovery.verify-passphrase", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.verifyPassphrase("passphrase");
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationAccountRecoveryContextProvider::complete", () => {
+    it("When an unexpected error occurred while recovering the account, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.account-recovery.recover-account", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.complete("passphrase", true);
+      expect(props.context.port.requestListeners["passbolt.account-recovery.recover-account"]).toHaveBeenCalledWith("passphrase", undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR);
+    });
+
+    it("When the account recovery is recovered the machine state should be set to: DOWNLOAD_RECOVERY_KIT", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.complete("passphrase", true);
+      expect(props.context.port.requestListeners["passbolt.account-recovery.recover-account"]).toHaveBeenCalledWith("passphrase", undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.DOWNLOAD_RECOVERY_KIT);
+    });
+  });
+
+  describe("AuthenticationAccountRecoveryContextProvider::downloadRecoveryKit", () => {
+    it("When the user requests the download of the recovery kit, the machine state should be remain to: DOWNLOAD_RECOVERY_KIT", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.complete("passphrase", true);
+      await contextProvider.downloadRecoveryKit();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.download-recovery-kit"]).toHaveBeenCalledTimes(1);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.DOWNLOAD_RECOVERY_KIT);
+    });
+
+    it("When an unexpected error occurred while downloading the recovery kit, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.account-recovery.download-recovery-kit", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.complete("passphrase", true);
+      await contextProvider.downloadRecoveryKit();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.download-recovery-kit"]).toHaveBeenCalledTimes(1);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR);
+    });
+  });
+
+  describe("AuthenticationAccountRecoveryContextProvider::handleRecoveryKitDownloaded", () => {
+    it("When the user has downloaded its recovery kit and signs in, the machine state should be set to: SIGNING_IN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.complete("passphrase", true);
+      await contextProvider.handleRecoveryKitDownloaded();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.sign-in"]).toHaveBeenCalledWith("passphrase", true, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.SIGNING_IN);
+    });
+
+    it("When the user has downloaded its recovery kit and but fails to sign-in, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.account-recovery.sign-in", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.complete("passphrase", true);
+      await contextProvider.handleRecoveryKitDownloaded();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.sign-in"]).toHaveBeenCalledWith("passphrase", true, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR);
+    });
+  });
+
+  describe("AuthenticationAccountRecoveryContextProvider::requestHelpCredentialsLost", () => {
+    it("When the user lost its passphrase and requests administrator help, the machine state should be set to: CHECK_MAILBOX", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.requestHelpCredentialsLost();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.request-help-credentials-lost"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.CHECK_MAILBOX);
+    });
+
+    it("When the user lost its passphrase and fails to request administrator help the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.account-recovery.request-help-credentials-lost", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationAccountRecoveryContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.requestHelpCredentialsLost();
+      expect(props.context.port.requestListeners["passbolt.account-recovery.request-help-credentials-lost"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationAccountRecoveryWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+});