passbolt-styleguide 3.5.2 → 3.6.0-alpha2

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

@@ -0,0 +1,264 @@
+/**
+ * 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 login workflow states.
+export const AuthenticationLoginWorkflowStates = {
+  ACCEPT_NEW_SERVER_KEY: "Accept new server key",
+  LOADING: "Loading",
+  SIGN_IN: "Sign in",
+  SIGN_IN_ERROR: "Sign in error",
+  SIGNING_IN: "Signing in",
+  INITIATE_ACCOUNT_RECOVERY: "Initiate account recovery",
+  HELP_CREDENTIALS_LOST: "Help credentials lost",
+  UNEXPECTED_ERROR: "Unexpected error",
+  CHECK_MAILBOX: "Check mailbox",
+};
+
+/**
+ * The authentication login context provider.
+ * Handle the business logic of the login and the manage the workflow.
+ * @type {React.Context<{}>}
+ */
+export const AuthenticationLoginContext = React.createContext({
+  // Workflow data.
+  state: null, // The current login workflow state.
+  serverKey: null, // The server key, state used when the server key changed.
+  error: null, // The current error if any, state used when an unexpected error occurred.
+
+  // Public workflow mutators.
+  checkPassphrase: () => {
+  }, // Whenever a user passphrase check is required.
+  signIn: () => {
+  }, // Whenever a user sign-in is required.
+  handleSwitchAccount: () => {
+  }, // Whenever a switch account is required.
+  acceptNewServerKey: () => {
+  }, // Whenever a new server gpg key is accepted.
+  needHelpCredentialsLost: () => {
+  }, // Whenever a user lost its passphrase.
+  requestHelpCredentialsLost: () => {
+  }, // Whenever the user wants to request help because it lost its credentials.
+  goToValidatePassphrase: () => {
+  }, // Whenever the users wants to go to the validate passphrase.
+});
+
+/**
+ * The authentication login context provider.
+ * Handle the business logic of the login and the manage the workflow.
+ */
+export class AuthenticationLoginContextProvider extends React.Component {
+  /**
+   * Default constructor
+   * @param props The component props
+   */
+  constructor(props) {
+    super(props);
+    this.state = this.defaultState;
+  }
+
+  /**
+   * Returns the default component state
+   */
+  get defaultState() {
+    return {
+      // Workflow data.
+      state: AuthenticationLoginWorkflowStates.LOADING, // The current login workflow state.
+      serverKey: null, // The server key, state used when the server key changed.
+      error: null, // The current error if any.
+
+      // Public workflow mutators.
+      checkPassphrase: this.checkPassphrase.bind(this), // Whenever a user passphrase check is required.
+      signIn: this.signIn.bind(this), // Whenever a user sign-in is required.
+      handleSwitchAccount: this.handleSwitchAccount.bind(this), // Whenever a switch account is required.
+      acceptNewServerKey: this.acceptNewServerKey.bind(this), // Whenever a new server gpg key is accepted.
+      needHelpCredentialsLost: this.needHelpCredentialsLost.bind(this), // Whenever a user lost its passphrase.
+      requestHelpCredentialsLost: this.requestHelpCredentialsLost.bind(this), // Whenever the user wants to request help because it lost its credentials.
+      goToValidatePassphrase: this.goToValidatePassphrase.bind(this), // Whenever the users wants to go to the validate passphrase.
+    };
+  }
+
+  /**
+   * Whenever the component is initialized
+   */
+  componentDidMount() {
+    this.initialize();
+  }
+
+  /**
+   * Initialize the authentication login workflow
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    await this.verifyServerKey();
+  }
+
+  /**
+   * Verify the server key.
+   * @returns {Promise<void>}
+   */
+  async verifyServerKey() {
+    try {
+      await this.props.context.port.request('passbolt.auth.verify-server-key');
+      await this.setState({state: AuthenticationLoginWorkflowStates.SIGN_IN});
+    } catch (error) {
+      await this.handleVerifyServerKeyFailure(error);
+    }
+  }
+
+  /**
+   * Whenever the verify server key has been done with failure
+   * @param error An error occurred while the server key verification
+   */
+  async handleVerifyServerKeyFailure(error) {
+    if (error.name === "KeyIsExpiredError") {
+      // Nothing to do. @todo document why?
+    } else if (error.name === "ServerKeyChangedError") {
+      const serverKey = await this.props.context.port.request('passbolt.auth.get-server-key');
+      await this.setState({state: AuthenticationLoginWorkflowStates.ACCEPT_NEW_SERVER_KEY, serverKey});
+    } else if (error.name === "UserNotFoundError") {
+      // This case should be treated by the background page itself, and the login form should not be displayed.
+    } else {
+      await this.setState({state: AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR, error: error});
+    }
+  }
+
+  /**
+   * Whenever the user wants to check its passphrase.
+   * @param {string} passphrase The user passphrase
+   * @returns {Promise<void>}
+   */
+  async checkPassphrase(passphrase) {
+    try {
+      await this.props.context.port.request('passbolt.auth.verify-passphrase', passphrase);
+    } catch (error) {
+      if (error.name === "InvalidMasterPasswordError" || error.name === "GpgKeyError") {
+        // Expected errors controlled by the component CheckPassphrase, throw it.
+        throw error;
+      } else {
+        await this.setState({state: AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR, error: error});
+      }
+    }
+  }
+
+  /**
+   * Whenever the user wants to sign in.
+   * @param {string} passphrase The user passphrase
+   * @param {boolean} rememberMe (Optional) Should the passphrase remembered? default false.
+   * @returns {Promise<void>}
+   */
+  async signIn(passphrase, rememberMe = false) {
+    await this.setState({state: AuthenticationLoginWorkflowStates.SIGNING_IN});
+    try {
+      await this.props.context.port.request('passbolt.auth.login', passphrase, rememberMe);
+      this.props.context.port.request('passbolt.auth.post-login-redirect');
+    } catch (error) {
+      await this.setState({state: AuthenticationLoginWorkflowStates.SIGN_IN_ERROR, error});
+    }
+  }
+
+  /**
+   * Whenever the user wants to switch account.
+   */
+  handleSwitchAccount() {
+    const url = `${this.props.context.userSettings.getTrustedDomain()}/users/recover?locale=${this.props.context.locale}`;
+    window.open(url, '_parent', 'noopener,noreferrer');
+  }
+
+  /**
+   * Whenever the user accepts the new server key.
+   * @returns {Promise<void>}
+   */
+  async acceptNewServerKey() {
+    try {
+      await this.props.context.port.request('passbolt.auth.replace-server-key');
+      this.setState({state: AuthenticationLoginWorkflowStates.SIGN_IN});
+    } catch (error) {
+      await this.setState({state: AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR, error: error});
+    }
+  }
+
+  /**
+   * Whenever the user lost its passphrase.
+   * @returns {Promise<void>}
+   */
+  async needHelpCredentialsLost() {
+    const canIUserAccountRecovery = this.props.context.siteSettings.canIUse('accountRecovery');
+    if (canIUserAccountRecovery) {
+      await this.setState({state: AuthenticationLoginWorkflowStates.INITIATE_ACCOUNT_RECOVERY});
+    } else {
+      await this.setState({state: AuthenticationLoginWorkflowStates.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.auth.request-help-credentials-lost');
+      await this.setState({state: AuthenticationLoginWorkflowStates.CHECK_MAILBOX});
+    } catch (error) {
+      await this.setState({state: AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR, error: error});
+    }
+  }
+
+  /**
+   * Whenever the users wants to go to the validate passphrase.
+   * @returns {Promise<void>}
+   */
+  async goToValidatePassphrase() {
+    await this.setState({state: AuthenticationLoginWorkflowStates.SIGN_IN});
+  }
+
+  /**
+   * Render the component
+   * @returns {JSX}
+   */
+  render() {
+    return (
+      <AuthenticationLoginContext.Provider value={this.state}>
+        {this.props.children}
+      </AuthenticationLoginContext.Provider>
+    );
+  }
+}
+
+AuthenticationLoginContextProvider.propTypes = {
+  context: PropTypes.any, // The application context
+  children: PropTypes.any // The children components
+};
+export default withAppContext(AuthenticationLoginContextProvider);
+
+/**
+ * Authentication login context consumer HOC
+ * @param {React.Component} WrappedComponent The component to wrap
+ */
+export function withAuthenticationLoginContext(WrappedComponent) {
+  return class WithAuthenticationContext extends React.Component {
+    render() {
+      return (
+        <AuthenticationLoginContext.Consumer>
+          {
+            AuthenticationLoginContext => <WrappedComponent
+              authenticationLoginContext={AuthenticationLoginContext} {...this.props} />
+          }
+        </AuthenticationLoginContext.Consumer>
+      );
+    }
+  };
+}

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

@@ -0,0 +1,79 @@
+/**
+ * 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 {defaultAppContext} from "../ExtAppContext.test.data";
+import MockPort from "../../test/mock/MockPort";
+import ServerKeyChangedError from "../../lib/Error/ServerKeyChangedError";
+import SiteSettings from "../../../shared/lib/Settings/SiteSettings";
+import siteSettingsFixture from "../../test/fixture/Settings/siteSettings";
+
+/**
+ * Default context
+ * @param {Object} appContext The props to override
+ * @returns {object}
+ */
+export function defaultAuthenticationLoginAppContext(appContext = {}) {
+  const port = new MockPort();
+  port.addRequestListener("passbolt.auth.verify-server-key", jest.fn(() => Promise.resolve()));
+  port.addRequestListener("passbolt.auth.get-server-key", jest.fn(() => Promise.resolve()));
+  port.addRequestListener("passbolt.auth.verify-passphrase", jest.fn(() => Promise.resolve()));
+  port.addRequestListener("passbolt.auth.login", jest.fn(() => Promise.resolve()));
+  port.addRequestListener("passbolt.auth.replace-server-key", jest.fn(() => Promise.resolve()));
+  port.addRequestListener("passbolt.auth.request-help-credentials-lost", jest.fn(() => Promise.resolve()));
+
+  const defaultAuthenticationLoginAppContext = {
+    port: port,
+    siteSettings: new SiteSettings(siteSettingsFixture)
+  };
+  return Object.assign(defaultAppContext(defaultAuthenticationLoginAppContext), appContext);
+}
+
+/**
+ * Default context with account recovery disabled
+ * @param {Object} appContext The props to override
+ * @returns {object}
+ */
+export function defaultAuthenticationLoginAppContextWithAccountRecoveryDisabled(appContext = {}) {
+  const siteSettingsWithAccountRecoveryDisabled = JSON.parse(JSON.stringify(siteSettingsFixture));
+  siteSettingsWithAccountRecoveryDisabled.passbolt.plugins.accountRecovery.enabled = false;
+  return defaultAuthenticationLoginAppContext({
+    siteSettings: new SiteSettings(siteSettingsWithAccountRecoveryDisabled),
+    ...appContext,
+  });
+}
+
+/**
+ * Default props.
+ * @param {Object} props The props to override
+ * @returns {object}
+ */
+export function defaultProps(props) {
+  const defaultProps = {
+    context: defaultAuthenticationLoginAppContext()
+  };
+  return Object.assign(defaultProps, props || {});
+}
+
+/**
+ * Decorate - with server key rotated.
+ * @param {Object} props The props to decorate
+ * @returns {object}
+ */
+export function withServerKeyChanged(props) {
+  props.context.port.addRequestListener("passbolt.auth.verify-server-key", jest.fn(() => Promise.reject(new ServerKeyChangedError())));
+  const serverKey = {fingerprint: "0c1d1761110d1e33c9006d1a5b1b332ed06426d3"};
+  props.context.port.addRequestListener("passbolt.auth.get-server-key", jest.fn(() => Promise.resolve(serverKey)));
+
+  return props;
+}

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

@@ -0,0 +1,234 @@
+/**
+ * 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 {AuthenticationLoginContextProvider, AuthenticationLoginWorkflowStates} from "./AuthenticationLoginContext";
+import {
+  defaultAuthenticationLoginAppContextWithAccountRecoveryDisabled,
+  defaultProps,
+  withServerKeyChanged
+} from "./AuthenticationLoginContext.test.data";
+import InvalidMasterPasswordError from "../../lib/Error/InvalidMasterPasswordError";
+
+beforeEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+
+describe("AuthenticationLoginContextProvider", () => {
+  describe("AuthenticationLoginContextProvider::constructor", () => {
+    it("The machine state should be by default set to: LOADING", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.LOADING);
+    });
+  });
+
+  describe("AuthenticationLoginContextProvider::initialize", () => {
+    it("Once the server key is verified the machine state should be set to: SIGN_IN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.auth.verify-server-key"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN);
+    });
+
+    it("If the server key changed the machine state should be set to: ACCEPT_NEW_SERVER_KEY", async() => {
+      const props = withServerKeyChanged(defaultProps());
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(4);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.auth.verify-server-key"]).toHaveBeenCalled();
+      expect(props.context.port.requestListeners["passbolt.auth.get-server-key"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.ACCEPT_NEW_SERVER_KEY);
+      expect(contextProvider.state.serverKey.fingerprint).toEqual("0c1d1761110d1e33c9006d1a5b1b332ed06426d3");
+    });
+
+    it("If an unexpected error occurred the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.auth.verify-server-key", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(props.context.port.requestListeners["passbolt.auth.verify-server-key"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationLoginContextProvider::acceptNewServerKey", () => {
+    it("When the new server key is accepted, the machine state should be set to: SIGN_IN", async() => {
+      const props = withServerKeyChanged(defaultProps());
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.ACCEPT_NEW_SERVER_KEY);
+      await contextProvider.acceptNewServerKey();
+      expect(props.context.port.requestListeners["passbolt.auth.replace-server-key"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN);
+    });
+
+    it("When an error occurred when the new server key is accepted, the machine state should be set to: SIGN_IN", async() => {
+      const props = withServerKeyChanged(defaultProps());
+      props.context.port.addRequestListener("passbolt.auth.replace-server-key", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(4);
+      await contextProvider.initialize();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.ACCEPT_NEW_SERVER_KEY);
+      await contextProvider.acceptNewServerKey();
+      expect(props.context.port.requestListeners["passbolt.auth.replace-server-key"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationLoginContextProvider::checkPassphrase", () => {
+    it("When a passphrase check succeed the machine state should remain on: SIGN_IN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.checkPassphrase("passphrase");
+      expect(props.context.port.requestListeners["passbolt.auth.verify-passphrase"]).toHaveBeenCalledWith("passphrase", undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN);
+    });
+
+    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.auth.verify-passphrase", jest.fn(() => Promise.reject(new InvalidMasterPasswordError())));
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      try {
+        await contextProvider.checkPassphrase("passphrase");
+        expect(false).toBeTruthy();
+      } catch (error) {
+        expect(props.context.port.requestListeners["passbolt.auth.verify-passphrase"]).toHaveBeenCalledWith("passphrase", undefined);
+        expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN);
+        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.auth.verify-passphrase", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.checkPassphrase("passphrase");
+      expect(props.context.port.requestListeners["passbolt.auth.verify-passphrase"]).toHaveBeenCalledWith("passphrase", undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+
+  describe("AuthenticationLoginContextProvider::signIn", () => {
+    it("When a sign-in succeed the machine state should remain on: SIGNING_IN", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.signIn("passphrase");
+      expect(props.context.port.requestListeners["passbolt.auth.login"]).toHaveBeenCalledWith("passphrase", false, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGNING_IN);
+    });
+
+    it("When the sign-in fails, the machine state shoudl be set to: SIGN_IN_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.auth.login", jest.fn(() => Promise.reject(new Error('Unexpected error'))));
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.signIn("passphrase");
+      expect(props.context.port.requestListeners["passbolt.auth.login"]).toHaveBeenCalledWith("passphrase", false, undefined);
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN_ERROR);
+    });
+  });
+
+  describe("AuthenticationLoginContextProvider::needHelpCredentialsLost", () => {
+    it("When the user needs help because it lost its passphrase and account recovery feature flag is enabled, the machine state should be set to: INITIATE_ACCOUNT_RECOVERY", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      await contextProvider.initialize();
+      await contextProvider.needHelpCredentialsLost();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.INITIATE_ACCOUNT_RECOVERY);
+    });
+
+    it("When the user needs help because it lost its passphrase and account recovery feature flag is disabled, the machine state should be set to: HELP_CREDENTIALS_LOST", async() => {
+      const props = defaultProps({context: defaultAuthenticationLoginAppContextWithAccountRecoveryDisabled()});
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+      await contextProvider.initialize();
+      await contextProvider.needHelpCredentialsLost();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.HELP_CREDENTIALS_LOST);
+    });
+  });
+
+  describe("AuthenticationLoginContextProvider::requestHelpCredentialsLost", () => {
+    it("When the user initiates an account recovery, the machine state should be set to: CHECK_MAILBOX", async() => {
+      const props = defaultProps();
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+      await contextProvider.initialize();
+      await contextProvider.requestHelpCredentialsLost();
+      expect(props.context.port.requestListeners["passbolt.auth.request-help-credentials-lost"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.CHECK_MAILBOX);
+    });
+
+    it("When the user fails to initiate an account recovery, the machine state should be set to: UNEXPECTED_ERROR", async() => {
+      const props = defaultProps();
+      props.context.port.addRequestListener("passbolt.auth.request-help-credentials-lost", jest.fn(() => Promise.reject(new Error("Unexpected error"))));
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+      await contextProvider.initialize();
+      await contextProvider.requestHelpCredentialsLost();
+      expect(props.context.port.requestListeners["passbolt.auth.request-help-credentials-lost"]).toHaveBeenCalled();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual("Unexpected error");
+    });
+  });
+});