passbolt-styleguide 3.8.4 → 3.9.0-alpha2

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

@@ -45,7 +45,8 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(2);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
+
       expect(props.context.port.requestListeners["passbolt.auth.verify-server-key"]).toHaveBeenCalled();
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN);
     });
@@ -56,7 +57,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(4);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       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);
@@ -70,7 +71,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(3);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       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");
@@ -84,7 +85,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(3);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.ACCEPT_NEW_SERVER_KEY);
       await contextProvider.acceptNewServerKey();
       expect(props.context.port.requestListeners["passbolt.auth.replace-server-key"]).toHaveBeenCalled();
@@ -98,7 +99,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(4);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.ACCEPT_NEW_SERVER_KEY);
       await contextProvider.acceptNewServerKey();
       expect(props.context.port.requestListeners["passbolt.auth.replace-server-key"]).toHaveBeenCalled();
@@ -114,7 +115,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(2);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       await contextProvider.checkPassphrase("passphrase");
       expect(props.context.port.requestListeners["passbolt.auth.verify-passphrase"]).toHaveBeenCalledWith("passphrase", undefined);
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN);
@@ -127,7 +128,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(3);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       try {
         await contextProvider.checkPassphrase("passphrase");
         expect(false).toBeTruthy();
@@ -145,7 +146,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(3);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       await contextProvider.checkPassphrase("passphrase");
       expect(props.context.port.requestListeners["passbolt.auth.verify-passphrase"]).toHaveBeenCalledWith("passphrase", undefined);
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR);
@@ -160,7 +161,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(2);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       await contextProvider.signIn("passphrase");
       expect(props.context.port.requestListeners["passbolt.auth.login"]).toHaveBeenCalledWith("passphrase", false, undefined);
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGNING_IN);
@@ -173,7 +174,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(2);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       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);
@@ -187,7 +188,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(1);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       await contextProvider.needHelpCredentialsLost();
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.INITIATE_ACCOUNT_RECOVERY);
     });
@@ -198,7 +199,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(1);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       await contextProvider.needHelpCredentialsLost();
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.HELP_CREDENTIALS_LOST);
     });
@@ -211,7 +212,7 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(2);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       await contextProvider.requestHelpCredentialsLost();
       expect(props.context.port.requestListeners["passbolt.auth.request-help-credentials-lost"]).toHaveBeenCalled();
       expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.CHECK_MAILBOX);
@@ -224,11 +225,88 @@ describe("AuthenticationLoginContextProvider", () => {
       mockComponentSetState(contextProvider);
 
       expect.assertions(3);
-      await contextProvider.initialize();
+      await contextProvider.componentDidMount();
       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");
     });
   });
+
+  describe("AuthenticationLoginContextProvider::handleSsoSignIn", () => {
+    it("When the user initiates an SSO sign-in, the context should call the sso context to handle the sign-in", async() => {
+      const props = defaultProps({
+        ssoContext: {
+          runSignInProcess: jest.fn(() => {})
+        }
+      });
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      await contextProvider.componentDidMount();
+
+      expect.assertions(1);
+      await contextProvider.handleSsoSignIn();
+      expect(props.ssoContext.runSignInProcess).toHaveBeenCalledTimes(1);
+    });
+
+    it("After a successful SSO sign-in the machine state should be SIGNING_IN", async() => {
+      const props = defaultProps({
+        ssoContext: {
+          runSignInProcess: jest.fn(() => {})
+        }
+      });
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      await contextProvider.componentDidMount();
+
+      expect.assertions(1);
+      await contextProvider.handleSsoSignIn();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGNING_IN);
+    });
+
+    it("When the user fails to sign-in for an unexpected reason, the machine state should be on UNEXPECTED_ERROR", async() => {
+      const error = new Error("This is an unexpected error");
+      const props = defaultProps({
+        ssoContext: {
+          runSignInProcess: jest.fn(() => { throw error; })
+        }
+      });
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      await contextProvider.componentDidMount();
+
+      expect.assertions(2);
+      await contextProvider.handleSsoSignIn();
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.UNEXPECTED_ERROR);
+      expect(contextProvider.state.error.message).toEqual(error.message);
+    });
+
+    it("When the user closes the popup, the state should remain on SIGN_IN and the error should be thrown back", async() => {
+      const error = new Error("The user closed the pop-up");
+      error.name = "UserClosedSsoPopUpError";
+
+      const props = defaultProps({
+        ssoContext: {
+          runSignInProcess: jest.fn(() => { throw error; })
+        }
+      });
+
+      const contextProvider = new AuthenticationLoginContextProvider(props);
+      mockComponentSetState(contextProvider);
+      await contextProvider.componentDidMount();
+
+      expect.assertions(2);
+
+      try {
+        await contextProvider.handleSsoSignIn();
+      } catch (e) {
+        expect(e).toStrictEqual(error);
+      }
+
+      expect(contextProvider.state.state).toEqual(AuthenticationLoginWorkflowStates.SIGN_IN);
+    });
+  });
 });

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

@@ -29,6 +29,7 @@ export const AuthenticationSetupWorkflowStates = {
   COMPLETING_SETUP: 'Completing setup',
   UNEXPECTED_ERROR: 'Unexpected Error',
   VALIDATE_PASSPHRASE: 'Validate passphrase',
+  CONFIGURING_SSO: "Configuring SSO"
 };
 
 /**

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

@@ -23,6 +23,8 @@ export const NavigationContext = React.createContext({
   // Administration
   onGoToAdministrationRequested: () => {
   }, // Whenever the users wants to navigate to the administration workspace
+  onGoToAdministrationSelfRegistrationRequested: () => {
+  }, // Whenever the users wants to navigate to the administration workspace self registration
   onGoToAdministrationMfaRequested: () => {
   }, // Whenever the users wants to navigate to the administration workspace mfa
   onGoToAdministrationUsersDirectoryRequested: () => {
@@ -37,6 +39,8 @@ export const NavigationContext = React.createContext({
   }, // Whenever the users wants to navigate to the administration workspace account recovery
   onGoToAdministrationSmtpSettingsRequested: () => {
   }, // Whenever the users wants to navigate to the administration workspace SMTP settings
+  onGoToAdministrationSsoRequested: () => {
+  }, // Whenever the user wants to navigate to the administration workspace sso
   // Passwords
   onGoToPasswordsRequested: () => {
   }, // Whenever the user wants to navigate to the passwords workspace
@@ -93,6 +97,8 @@ class NavigationContextProvider extends React.Component {
       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
       onGoToAdministrationSmtpSettingsRequested: this.onGoToAdministrationSmtpSettingsRequested.bind(this), // Whenever the users wants to navigate to the administration workspace SMTP settings
+      onGoToAdministrationSelfRegistrationRequested: this.onGoToAdministrationSelfRegistrationRequested.bind(this), //Whenever the users wants to navigate to the administration workspace self registration settings
+      onGoToAdministrationSsoRequested: this.onGoToAdministrationSsoRequested.bind(this), // Whenever the user wants to navigate to the administration workspace sso
       // Passwords
       onGoToPasswordsRequested: this.onGoToPasswordsRequested.bind(this), // Whenever the user wants to navigate to the passwords workspace
       // Users
@@ -151,6 +157,8 @@ class NavigationContextProvider extends React.Component {
       pathname = "/app/administration/users-directory";
     } else if (this.isSmtpSettingsEnable) {
       pathname = "/app/administration/smtp-settings";
+    } else if (this.isSelfRegistrationEnable) {
+      pathname = "/app/administration/self-registation";
     }
     await this.goTo("api", pathname);
   }
@@ -163,6 +171,15 @@ class NavigationContextProvider extends React.Component {
     await this.goTo("api", "/app/administration/mfa");
   }
 
+  /**
+   * Whenever the user wants to navigate to the administration workspace selft registration.
+   * @returns {Promise<void>}
+   */
+  async onGoToAdministrationSelfRegistrationRequested() {
+    await this.goTo("api", "/app/administration/self-registration");
+  }
+
+
   /**
    * Whenever the user wants to navigate to the administration workspace users directory.
    * @returns {Promise<void>}
@@ -211,6 +228,14 @@ class NavigationContextProvider extends React.Component {
     await this.goTo("browser-extension", "/app/administration/account-recovery");
   }
 
+  /**
+   * Whenever the user wants to navigate to the administration workspace sso.
+   * @returns {Promise<void>}
+   */
+  async onGoToAdministrationSsoRequested() {
+    await this.goTo("browser-extension", "/app/administration/sso");
+  }
+
   /**
    * Returns true if the user has the MFA capability
    * @returns {boolean}
@@ -238,6 +263,15 @@ class NavigationContextProvider extends React.Component {
     return siteSettings && siteSettings.canIUse('smtpSettings');
   }
 
+  /**
+   * Returns true if the user has the self registration enabled
+   * @returns {boolean}
+   */
+  get isSelfRegistrationEnable() {
+    const siteSettings = this.props.context.siteSettings;
+    return siteSettings && siteSettings.canIUse('selfRegistration');
+  }
+
   /*
    * =============================================================
    *  Passwords navigation

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

@@ -0,0 +1,151 @@
+/**
+ * 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.9.0
+ */
+import React from "react";
+import PropTypes from "prop-types";
+import {withAppContext} from "./AppContext";
+import {withTranslation} from "react-i18next";
+
+export const SsoContext = React.createContext({
+  loadSsoConfiguration: () => {}, // Load the current sso configuration and store it in the state
+  getProvider: () => {}, // Return the current sso configuration from the context state
+  hasUserAnSsoKit: () => {}, // Returns true if the current user has an SSO kit built locally
+  runSignInProcess: () => {}, // Launches the SSO process with the configured provider
+});
+
+/**
+ * The related context provider
+ */
+export class SsoContextProvider 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() {
+    this.handleSpecificError = this.handleSpecificError.bind(this);
+    return {
+      ssoLocalConfiguredProvider: null, // the provider configured for the local SSO kit if any, null otherwise
+      loadSsoConfiguration: this.loadSsoConfiguration.bind(this), // Load the current sso configuration and store it in the state
+      getProvider: this.getProvider.bind(this), // Return the current sso provider configured
+      hasUserAnSsoKit: this.hasUserAnSsoKit.bind(this), // Returns true if the current user has an SSO kit built locally
+      runSignInProcess: this.runSignInProcess.bind(this), // Launches the SSO process with the configured provider
+    };
+  }
+
+  /**
+   * Find the sso configuration
+   * @return {Promise<void>}
+   */
+  async loadSsoConfiguration() {
+    const ssoLocalConfiguredProvider = await this.props.context.port.request("passbolt.sso.get-local-configured-provider");
+    this.setState({ssoLocalConfiguredProvider});
+  }
+
+  /**
+   * Get the current sso provider configured.
+   * @returns {string}
+   */
+  getProvider() {
+    return this.state.ssoLocalConfiguredProvider;
+  }
+
+  /**
+   * Returns true if the current user has an SSO kit built locally
+   * @returns {boolean}
+   */
+  hasUserAnSsoKit() {
+    return Boolean(this.state.ssoLocalConfiguredProvider);
+  }
+
+  /**
+   * Launches the SSO process with the configured provider
+   * @returns {Promise<void>}
+   */
+  async runSignInProcess() {
+    try {
+      const provider = this.getProvider();
+      await this.props.context.port.request(`passbolt.sso.sign-in-with-${provider}`);
+      await this.props.context.port.request('passbolt.auth.post-login-redirect');
+    } catch (e) {
+      console.error(e);
+      this.handleSpecificError(e);
+      throw e;
+    }
+  }
+
+  /**
+   * Handles error from the background page during SSO sign-in.
+   * @param {Error} e
+   */
+  handleSpecificError(e) {
+    let errorToThrow = e;
+    switch (e.name) {
+      case 'InvalidMasterPasswordError': {
+        errorToThrow = new Error(this.props.t("The passphrase from the SSO kit doesn't match your private key: {{error}}", {error: e.message}));
+        break;
+      }
+      case 'OutdatedSsoKitError': {
+        errorToThrow = new Error(this.props.t("The SSO kit is outdated and can't be used to decrypt your passphrase: {{error}}", {error: e.message}));
+        break;
+      }
+    }
+
+    throw errorToThrow;
+  }
+
+  /**
+   * Render the component
+   * @returns {JSX}
+   */
+  render() {
+    return (
+      <SsoContext.Provider value={this.state}>
+        {this.props.children}
+      </SsoContext.Provider>
+    );
+  }
+}
+
+SsoContextProvider.propTypes = {
+  context: PropTypes.any, // The application context
+  children: PropTypes.any, // The children components
+  t: PropTypes.func, // The translation function
+};
+export default withAppContext(withTranslation('common')(SsoContextProvider));
+
+/**
+ * Resource Workspace Context Consumer HOC
+ * @param WrappedComponent
+ */
+export function withSso(WrappedComponent) {
+  return class withSso extends React.Component {
+    render() {
+      return (
+        <SsoContext.Consumer>
+          {
+            ssoContext => <WrappedComponent ssoContext={ssoContext} {...this.props} />
+          }
+        </SsoContext.Consumer>
+      );
+    }
+  };
+}
+

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

@@ -0,0 +1,36 @@
+/**
+ * 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.9.0
+ */
+
+import {defaultAppContext} from "./ExtAppContext.test.data";
+import MockPort from "../test/mock/MockPort";
+
+/**
+ * Default context
+ * @param {Object} data The props to override
+ * @param {string} providerId the sso provider id configured
+ * @returns {object}
+ */
+export function defaultProps(data = {}, providerId = null) {
+  const port = new MockPort();
+  port.addRequestListener("passbolt.sso.get-local-configured-provider", jest.fn(() => Promise.resolve(providerId)));
+  port.addRequestListener("passbolt.sso.sign-in-with-azure", jest.fn(() => Promise.resolve()));
+  port.addRequestListener("passbolt.auth.post-login-redirect", jest.fn(() => Promise.resolve()));
+
+  const defaultAuthenticationLoginAppContext = {
+    context: {
+      port: port,
+    }
+  };
+  return Object.assign(defaultAppContext(defaultAuthenticationLoginAppContext), data);
+}

package/src/react-extension/contexts/SsoContext.test.js

@@ -0,0 +1,104 @@
+/**
+ * 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.9.0
+ */
+
+import each from "jest-each";
+import mockComponentSetState from "../test/mock/components/React/mockSetState";
+import {SsoContextProvider} from "./SsoContext";
+import {defaultProps} from "./SsoContext.test.data";
+
+beforeEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+
+describe("SsoContextProvider", () => {
+  each([
+    {name: "provider is Azure", providerId: "azure"},
+    {name: "no provider available", providerId: null},
+  ]).describe(`SsoContextProvider configuration handling`, scenario => {
+    it(`SsoContextProvider::loadSsoConfiguration: Should call for the background page to retrieve the SSO provider data and set it on its state: ${scenario.name}`, async() => {
+      const props = defaultProps(null, scenario.providerId);
+      const contextProvider = new SsoContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+
+      await contextProvider.loadSsoConfiguration();
+
+      expect(props.context.port.requestListeners["passbolt.sso.get-local-configured-provider"]).toHaveBeenCalled();
+      expect(contextProvider.state.ssoLocalConfiguredProvider).toEqual(scenario.providerId);
+    });
+
+    it(`SsoContextProvider::getProvider: Should return the SSO provider id: ${scenario.name}`, async() => {
+      const props = defaultProps(null, scenario.providerId);
+      const contextProvider = new SsoContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+
+      await contextProvider.loadSsoConfiguration();
+
+      expect(contextProvider.getProvider()).toEqual(scenario.providerId);
+    });
+
+    it(`SsoContextProvider::hasUserAnSsoKit: Should return true when an SSO provider is available false otherwise: ${scenario.name}`, async() => {
+      const props = defaultProps(null, scenario.providerId);
+      const contextProvider = new SsoContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(1);
+
+      await contextProvider.loadSsoConfiguration();
+
+      expect(contextProvider.hasUserAnSsoKit()).toEqual(Boolean(scenario.providerId));
+    });
+  });
+
+  describe("SsoContextProvider::runSignInProcess", () => {
+    it("Should call for the background page to delegate the Sign in process", async() => {
+      const props = defaultProps(null, "azure");
+      const contextProvider = new SsoContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(2);
+
+      await contextProvider.loadSsoConfiguration();
+      await contextProvider.runSignInProcess();
+
+      expect(props.context.port.requestListeners["passbolt.sso.sign-in-with-azure"]).toHaveBeenCalledTimes(1);
+      expect(props.context.port.requestListeners["passbolt.auth.post-login-redirect"]).toHaveBeenCalledTimes(1);
+    });
+
+    it("Should throw an error when something wrong happens during sign-in", async() => {
+      const error = new Error("An unexpected error occured");
+      const props = defaultProps(null, "azure");
+      props.context.port.addRequestListener("passbolt.sso.sign-in-with-azure", jest.fn(() => Promise.reject(error)));
+      const contextProvider = new SsoContextProvider(props);
+      mockComponentSetState(contextProvider);
+
+      expect.assertions(3);
+
+      await contextProvider.loadSsoConfiguration();
+
+      try {
+        await contextProvider.runSignInProcess();
+      } catch (e) {
+        expect(e).toStrictEqual(error);
+      }
+
+      expect(props.context.port.requestListeners["passbolt.sso.sign-in-with-azure"]).toHaveBeenCalledTimes(1);
+      expect(props.context.port.requestListeners["passbolt.auth.post-login-redirect"]).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/react-extension/lib/Domain/DomainUtil.js

@@ -0,0 +1,70 @@
+/**
+ * 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.8.3
+ */
+
+import XRegExp from 'xregexp';
+import {nonProfessionalDomains} from './Domains';
+
+const HOSTNAMEREGEX = "(?:[_\\p{L}0-9][-_\\p{L}0-9]*\\.)*(?:[\\p{L}0-9][-\\p{L}0-9]{0,62})\\.(?:(?:[a-z]{2}\\.)?[a-z]{2,})";
+
+/**
+ * The DomainUtil which will interact with domains
+ */
+class DomainUtil {
+  /**
+   * Extract domain for email address
+   * @param {string} domain
+   * @returns {String}
+   */
+  static extractDomainFromEmail(email) {
+    const regex = XRegExp(`(?<=@)${HOSTNAMEREGEX}`);
+    const match = XRegExp.match(email, regex);
+    return match || "";
+  }
+
+  /**
+   * Check if the domain is a profesionnal
+   * @param {string} domain
+   * @returns {Boolean}
+   */
+  static isProfessional(domain) {
+    return !nonProfessionalDomains.includes(domain);
+  }
+
+  /**
+   * Check the domain through regex and URL validation
+   * @param {string} domain
+   * @returns {Void}
+   */
+  static checkDomainValidity(domain) {
+    const regex = XRegExp(`^${HOSTNAMEREGEX}$`);
+    if (!regex.test(domain)) {
+      throw new Error(
+        "Cannot parse domain. The domain does not match the pattern."
+      );
+    }
+    try {
+      // we had https to avoid issue for validation
+      const url = new URL(`https://${domain}`);
+      if (!url.host) {
+        throw new Error(
+          "Cannot parse domain. The domain does not match the pattern."
+        );
+      }
+    } catch (error) {
+      throw new Error("Cannot parse domain. The domain is not valid.");
+    }
+  }
+}
+
+export default DomainUtil;