passbolt-styleguide 3.8.4 → 3.9.0-alpha2

package/src/shared/services/forms/Mfa/MfaFormService.test.js

@@ -0,0 +1,341 @@
+/**
+ * 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.0
+ */
+
+import {AdminMfaContextProvider} from "../../../../react-extension/contexts/Administration/AdministrationMfa/AdministrationMfaContext";
+import {defaultProps, mockDuoError} from "../../../../react-extension/components/Administration/DisplayMfaAdministration/DisplayMfaAdministration.test.data";
+import {enableFetchMocks} from 'jest-fetch-mock';
+import MfaFormService from './MfaFormService';
+import {mockYubikeyError} from '../../../../react-extension/components/Administration/DisplayMfaAdministration/DisplayMfaAdministration.test.data';
+
+beforeEach(() => {
+  jest.resetModules();
+});
+
+describe("MfaFormService", () => {
+  let adminMfaContext, // The adminMfaContext to test
+    mfaFormService;
+  const translation = message => message;
+  const props = defaultProps(); // The props to pass
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    adminMfaContext = new AdminMfaContextProvider(props);
+    const setStateMock = state => adminMfaContext.state = Object.assign(adminMfaContext.state, state);
+    jest.spyOn(adminMfaContext, "setState").mockImplementation(setStateMock);
+    MfaFormService.killInstance();
+    mfaFormService = MfaFormService.getInstance(adminMfaContext, translation);
+    enableFetchMocks();
+  });
+
+  describe("MfaFormService::getInstance", () => {
+    it("should be a singleton", () => {
+      expect.assertions(1);
+      expect(mfaFormService).toBeDefined();
+    });
+
+    it("should not create a new instance", () => {
+      const newInstance = MfaFormService.getInstance();
+      expect.assertions(1);
+      expect(mfaFormService).toEqual(newInstance);
+    });
+  });
+
+
+  describe("MfaFormService::killInstance", () => {
+    it("should kill the instance and create a new one", () => {
+      MfaFormService.killInstance();
+      mfaFormService = MfaFormService.getInstance(null, null);
+      expect.assertions(1);
+      expect(mfaFormService).toEqual({"context": null, "translation": null});
+    });
+  });
+
+  describe("MfaFormService::validateYubikeyClientIdentifier", () => {
+    it("should return required message", () => {
+      const requiredMessage = "A client identifier is required.";
+      const result = mfaFormService.validateYubikeyClientIdentifier("");
+      expect.assertions(2);
+      expect(result).toEqual(requiredMessage);
+      expect(adminMfaContext.getErrors().yubikeyClientIdentifierError).toEqual(requiredMessage);
+    });
+    it("should return regex message", () => {
+      const errorMessage = "The client identifier should be an integer.";
+      //Letters are not allowed
+      let result = mfaFormService.validateYubikeyClientIdentifier("FFFF");
+
+      expect.assertions(4);
+      expect(result).toEqual(errorMessage);
+      //Max size 64
+      result = mfaFormService.validateYubikeyClientIdentifier("F".repeat(65));
+      expect(result).toEqual(errorMessage);
+      //No special characters
+      result = mfaFormService.validateYubikeyClientIdentifier("@@");
+      expect(result).toEqual(errorMessage);
+      expect(adminMfaContext.getErrors().yubikeyClientIdentifierError).toEqual(errorMessage);
+    });
+    it("should not return message", () => {
+      //Only numbers are allowed
+      const result = mfaFormService.validateYubikeyClientIdentifier("123456789");
+      expect.assertions(2);
+      expect(result).toEqual(null);
+      expect(adminMfaContext.getErrors().yubikeyClientIdentifierError).toEqual(null);
+    });
+  });
+
+  describe("MfaFormService::validateYubikeySecretKey", () => {
+    it("should return required message", () => {
+      const requiredMessage = "A secret key is required.";
+      const result = mfaFormService.validateYubikeySecretKey("");
+      expect.assertions(2);
+      expect(result).toEqual(requiredMessage);
+      expect(adminMfaContext.getErrors().yubikeySecretKeyError).toEqual(requiredMessage);
+    });
+    it("should return regex message", () => {
+      const errorMessage = "The client identifier should be an integer.";
+      //only / = + characters are allowed
+      let result = mfaFormService.validateYubikeyClientIdentifier("FFFFF12345**");
+      expect.assertions(4);
+      expect(result).toEqual(errorMessage);
+      //Max size 128
+      result = mfaFormService.validateYubikeyClientIdentifier("F".repeat(129));
+      expect(result).toEqual(errorMessage);
+      //Min size 10
+      result = mfaFormService.validateYubikeyClientIdentifier("@".repeat(9));
+      expect(result).toEqual(errorMessage);
+      expect(adminMfaContext.getErrors().yubikeyClientIdentifierError).toEqual(errorMessage);
+    });
+    it("should not return message", () => {
+      //Only without sensitive letters and number and / = + are allowed
+      let result = mfaFormService.validateYubikeySecretKey("mk6lyijz2AIhX3D9eLIYAxv63Co=");
+      expect(result).toEqual(null);
+      result = mfaFormService.validateYubikeySecretKey("mk6lyijz2AIhX3D9eLIYAxv63Co+");
+      expect(result).toEqual(null);
+      result = mfaFormService.validateYubikeySecretKey("mk6lyijz2AIhX3D9eLIYAxv63Co/");
+      expect(result).toEqual(null);
+      expect(adminMfaContext.getErrors().yubikeySecretKeyError).toEqual(null);
+      expect.assertions(4);
+    });
+  });
+
+  describe("MfaFormService::validateDuoHostname", () => {
+    it("should return required message", () => {
+      const requiredMessage = "A hostname is required.";
+      const result = mfaFormService.validateDuoHostname("");
+      expect(result).toEqual(requiredMessage);
+      expect(adminMfaContext.getErrors().duoHostnameError).toEqual(requiredMessage);
+      expect.assertions(2);
+    });
+    it("should return regex message", () => {
+      const errorMessage = "This is not a valid hostname.";
+      //hostname should start with 'api-'
+      let result = mfaFormService.validateDuoHostname("123456789-duosecurity.com");
+      expect(result).toEqual(errorMessage);
+      //hostname should include '-duosecurity.com'
+      result = mfaFormService.validateDuoHostname("api-123456789-passbolt.com");
+      expect(result).toEqual(errorMessage);
+      //hostname should not include special character
+      result = mfaFormService.validateDuoHostname("api-123456@89-duosecurity.com");
+      //hostname have uuid with max 16 characters
+      result = mfaFormService.validateDuoHostname("api-0123456789azertyu-duosecurity.com");
+      //hostname have uuid with min 8 characters
+      result = mfaFormService.validateDuoHostname("api-1L-duosecurity.com");
+      expect(result).toEqual(errorMessage);
+      expect(adminMfaContext.getErrors().duoHostnameError).toEqual(errorMessage);
+      expect.assertions(4);
+    });
+    it("should not return message", () => {
+      const result = mfaFormService.validateDuoHostname("api-634253af.duosecurity.com");
+      expect.assertions(2);
+      expect(result).toEqual(null);
+      expect(adminMfaContext.getErrors().duoHostnameError).toEqual(null);
+    });
+  });
+
+  describe("MfaFormService::validateDuoIntegrationKey", () => {
+    it("should return required message", () => {
+      const requiredMessage = "An integration key is required.";
+      const result = mfaFormService.validateDuoIntegrationKey("");
+      expect.assertions(2);
+      expect(result).toEqual(requiredMessage);
+      expect(adminMfaContext.getErrors().duoIntegrationKeyError).toEqual(requiredMessage);
+    });
+    it("should return regex message", () => {
+      const errorMessage = "This is not a valid integration key.";
+      //Min size 64
+      let result = mfaFormService.validateDuoIntegrationKey("F".repeat(15));
+      expect(result).toEqual(errorMessage);
+      //Max size 64
+      result = mfaFormService.validateDuoIntegrationKey("F".repeat(33));
+      expect(result).toEqual(errorMessage);
+      //No special characters
+      result = mfaFormService.validateDuoIntegrationKey("@&'");
+      expect(result).toEqual(errorMessage);
+      expect(adminMfaContext.getErrors().duoIntegrationKeyError).toEqual(errorMessage);
+      expect.assertions(4);
+    });
+    it("should not return message", () => {
+      //only upper and lowercase letters with numbers
+      const result = mfaFormService.validateDuoIntegrationKey("0123456789AZERTY");
+      expect(result).toEqual(null);
+      expect(adminMfaContext.getErrors().duoIntegrationKeyError).toEqual(null);
+      expect.assertions(2);
+    });
+  });
+
+  describe("MfaFormService::validateDuoSecretKey", () => {
+    it("should return required message", () => {
+      const requiredMessage = "A secret key is required.";
+      const result = mfaFormService.validateDuoSecretKey("");
+      expect(result).toEqual(requiredMessage);
+      expect(adminMfaContext.getErrors().duoSecretKeyError).toEqual(requiredMessage);
+      expect.assertions(2);
+    });
+    it("should return regex message", () => {
+      const errorMessage = "This is not a valid secret key.";
+
+      //Min size 32
+      let result = mfaFormService.validateDuoSecretKey("F".repeat(31));
+      expect(result).toEqual(errorMessage);
+      //Max size 129
+      result = mfaFormService.validateDuoSecretKey("F".repeat(129));
+      expect(result).toEqual(errorMessage);
+      //No special characters
+      result = mfaFormService.validateDuoSecretKey("@$ù=");
+      expect(result).toEqual(errorMessage);
+      expect(adminMfaContext.getErrors().duoSecretKeyError).toEqual(errorMessage);
+      expect.assertions(4);
+    });
+    it("should not return message", () => {
+      //only upper and lowercase letters with numbers
+      const result = mfaFormService.validateDuoSecretKey("aZ7".repeat(11));
+      expect(result).toEqual(null);
+      expect(adminMfaContext.getErrors().duoSecretKeyError).toEqual(null);
+      expect.assertions(2);
+    });
+  });
+
+  describe("MfaFormService::validateDuoSalt", () => {
+    it("should return required message", () => {
+      const requiredMessage = "A salt is required.";
+      const result = mfaFormService.validateDuoSalt("");
+      expect(result).toEqual(requiredMessage);
+      expect(adminMfaContext.getErrors().duoSaltError).toEqual(requiredMessage);
+      expect.assertions(2);
+    });
+    it("should return regex message", () => {
+      const errorMessage = "The salt should be between 40 and 128 characters in length.";
+
+      //Min size 32
+      let result = mfaFormService.validateDuoSalt("F".repeat(39));
+      expect(result).toEqual(errorMessage);
+      //Max size 129
+      result = mfaFormService.validateDuoSalt("F".repeat(129));
+      expect(result).toEqual(errorMessage);
+      expect(adminMfaContext.getErrors().duoSaltError).toEqual(errorMessage);
+      expect.assertions(3);
+    });
+    it("should not return message", () => {
+      //Oall characters allowed
+      const result = mfaFormService.validateDuoSalt("aZ7@".repeat(10));
+      expect(result).toEqual(null);
+      expect(adminMfaContext.getErrors().duoSaltError).toEqual(null);
+      expect.assertions(2);
+    });
+  });
+
+  describe("MfaFormService::validateDuoInputs", () => {
+    it("should not validate if duo is not selected", () => {
+      adminMfaContext.setSettings("duoToggle", false);
+      const result = mfaFormService.validateDuoInputs();
+      expect(result).toEqual({});
+      expect.assertions(1);
+    });
+
+    it("should validate if duo is selected", () => {
+      adminMfaContext.setSettings("duoToggle", true);
+
+      jest.spyOn(mfaFormService, "validateDuoHostname");
+      jest.spyOn(mfaFormService, "validateDuoIntegrationKey");
+      jest.spyOn(mfaFormService, "validateDuoSecretKey");
+      jest.spyOn(mfaFormService, "validateDuoSalt");
+
+      const result = mfaFormService.validateDuoInputs();
+      const settings = adminMfaContext.getSettings();
+
+
+      expect(mfaFormService.validateDuoHostname).toHaveBeenCalledWith(settings.duoHostname);
+      expect(mfaFormService.validateDuoIntegrationKey).toHaveBeenCalledWith(settings.duoIntegrationKey);
+      expect(mfaFormService.validateDuoSecretKey).toHaveBeenCalledWith(settings.duoSecretKey);
+      expect(mfaFormService.validateDuoSalt).toHaveBeenCalledWith(settings.duoSalt);
+      expect(result).toEqual(mockDuoError());
+      expect.assertions(5);
+    });
+  });
+
+  describe("MfaFormService::validateYubikeyInputs", () => {
+    it("should not validate if yubikey is not selected", () => {
+      adminMfaContext.setSettings("yubikeyToggle", false);
+
+      const result = mfaFormService.validateYubikeyInputs();
+
+      expect(result).toEqual({});
+    });
+
+    it("should validate if duo is selected", () => {
+      adminMfaContext.setSettings("yubikeyToggle", true);
+
+      jest.spyOn(mfaFormService, "validateYubikeyClientIdentifier");
+      jest.spyOn(mfaFormService, "validateYubikeySecretKey");
+
+      const result = mfaFormService.validateYubikeyInputs();
+      const settings = adminMfaContext.getSettings();
+
+      expect(mfaFormService.validateYubikeyClientIdentifier).toHaveBeenCalledWith(settings.yubikeyClientIdentifier);
+      expect(mfaFormService.validateYubikeySecretKey).toHaveBeenCalledWith(settings.yubikeySecretKey);
+      expect(result).toEqual(mockYubikeyError());
+      expect.assertions(3);
+    });
+  });
+
+  describe("MfaFormService::validate", () => {
+    it("should return false if there are some validation issues", async() => {
+      adminMfaContext.setSettings("yubikeyToggle", true);
+      adminMfaContext.setSettings("duoToggle", true);
+
+      jest.spyOn(mfaFormService, "validateYubikeyInputs");
+      jest.spyOn(mfaFormService, "validateDuoInputs");
+
+      const result = await mfaFormService.validate();
+      const errors = adminMfaContext.getErrors();
+
+      expect(result).toBeFalsy();
+      expect(mfaFormService.validateYubikeyInputs).toHaveBeenCalled();
+      expect(mfaFormService.validateDuoInputs).toHaveBeenCalled();
+      expect(errors).toEqual(Object.assign(mockYubikeyError(), mockDuoError()));
+      expect.assertions(4);
+    });
+    it("should return true if validation succeed", async() => {
+      jest.spyOn(mfaFormService, "validateYubikeyInputs");
+      jest.spyOn(mfaFormService, "validateDuoInputs");
+
+      const result = await mfaFormService.validate();
+
+      expect(result).toBeTruthy();
+      expect(mfaFormService.validateYubikeyInputs).toHaveBeenCalled();
+      expect(mfaFormService.validateDuoInputs).toHaveBeenCalled();
+      expect.assertions(3);
+    });
+  });
+});
+

package/src/shared/services/forms/selfRegistration/SelfRegistrationFormService.js

@@ -0,0 +1,92 @@
+/**
+ * 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.0
+ */
+
+import DomainUtil from '../../../../react-extension/lib/Domain/DomainUtil';
+import MapObject from '../../../../react-extension/lib/Map/MapObject';
+
+/**
+ * Model related to the Self Registration form settings
+ */
+class SelfRegistrationFormService {
+  /**
+   * Constructor
+   *
+   * @param {context} context
+   * @public
+   */
+  constructor(translate) {
+    this.translate = translate;
+  }
+
+  fields = new Map();
+
+  /**
+   * Validate the form.
+   * @returns {Promise<boolean>}
+   */
+  async validate(domains) {
+    this.fields = domains;
+    // Validate the form inputs.
+    const validation = this.validateInputs();
+    //Check if we have errors
+    return validation;
+  }
+
+  /**
+   * Validate inputs.
+   * @returns {Promise<void>}
+   */
+  validateInputs() {
+    const errors = new Map();
+    this.fields.forEach((value, key) => {
+      this.validateInput(key, value, errors);
+    });
+    return errors;
+  }
+
+  /**
+   * Validate inputs.
+   * @params {string} The input name
+   * @params {string} The input value
+   * @returns {Promise<void>}
+   */
+  async validateInput(key, value, errors) {
+    if (!value.length) {
+      errors.set(key, this.translate("A domain is required."));
+    } else {
+      try {
+        DomainUtil.checkDomainValidity(value);
+      } catch {
+        errors.set(key, this.translate("This should be a valid domain"));
+      }
+    }
+    //Avoid duplicate value
+    this.checkDuplicateValue(errors);
+  }
+
+  /**
+   * Check if we have a duplication.
+   * @returns {Promise<void>}
+   */
+  checkDuplicateValue(inputErrors) {
+    this.fields.forEach((value, key) => {
+      const hasDuplicate = MapObject.listValues(this.fields).filter(domain => domain === value && domain !== "").length > 1;
+      if (hasDuplicate) {
+        inputErrors.set(key, this.translate("This domain already exist"));
+      }
+    });
+  }
+}
+
+export default  SelfRegistrationFormService;

package/src/shared/services/forms/selfRegistration/SelfRegistrationFormService.test.js

@@ -0,0 +1,101 @@
+/**
+ *import { userDirectoryContext } from '../../../../react-extension/contexts/Administration/AdministrationMfa/AdministrationMfaContext';
+ * 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 {enableFetchMocks} from 'jest-fetch-mock';
+import {AdminSelfRegistrationContextProvider} from "../../../../react-extension/contexts/Administration/AdministrationSelfRegistration/AdministrationSelfRegistrationContext";
+import {defaultProps} from '../../../../react-extension/components/Administration/DisplaySelfRegistrationAdministration/ConfirmSaveSelfRegistrationSettings/ConfirmSaveSelfRegistrationSettings.test.data';
+import SelfRegistrationFormService from './SelfRegistrationFormService';
+import SelfRegistrationDomainsViewModel from '../../../models/selfRegistration/SelfRegistrationDomainsViewModel';
+import MapObject from '../../../../react-extension/lib/Map/MapObject';
+
+beforeEach(() => {
+  jest.resetModules();
+});
+
+describe("SelfRegistrationFormService", () => {
+  let selfRegistrationContext, // The selfRegistrationContext to test
+    selfRegistrationFormService;
+  const translation = message => message;
+  const props = defaultProps(); // The props to pass
+  const uuid = "2bb8b096-06ce-4c9a-a627-ec30ce045a83";
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    selfRegistrationContext = new AdminSelfRegistrationContextProvider(props);
+    mockState(selfRegistrationContext);
+    selfRegistrationFormService = new SelfRegistrationFormService(translation);
+    enableFetchMocks();
+  });
+
+
+  describe("UserDirectoryFormService::validateInput", () => {
+    it("should return required message", async() => {
+      expect.assertions(1);
+      const errors = new Map();
+      await selfRegistrationFormService.validateInput(uuid, "", errors);
+      expect(errors.get(uuid)).toEqual("A domain is required.");
+    });
+
+    it("should return a message to reject domain format", async() => {
+      expect.assertions(1);
+      const errors = new Map();
+      await selfRegistrationFormService.validateInput(uuid, "localhost", errors);
+      expect(errors.get(uuid)).toEqual("This should be a valid domain");
+    });
+
+    it("should call checkDuplicateValue", async() => {
+      jest.spyOn(selfRegistrationFormService, "checkDuplicateValue");
+      const errors = new Map();
+      await selfRegistrationFormService.validateInput(uuid, "hello.world", errors);
+      expect.assertions(1);
+      expect(selfRegistrationFormService.checkDuplicateValue).toHaveBeenCalled();
+    });
+  });
+
+  describe("UserDirectoryFormService::checkDuplicateValue", () => {
+    it("should return a message which indicate that the domain already exist", async() => {
+      selfRegistrationFormService.fields = ["passbolt.com", "passbolt.com"];
+      expect.assertions(1);
+      const errors = new Map();
+      await selfRegistrationFormService.checkDuplicateValue(errors);
+      expect(MapObject.listValues(errors)).toEqual(["This domain already exist", "This domain already exist"]);
+    });
+
+    it("should not return a message", async() => {
+      const domains = new SelfRegistrationDomainsViewModel(
+        {data: {"allowed_domains": ["passbolt.com"]}}
+      );
+      await selfRegistrationContext.setDomains(domains);
+      expect.assertions(1);
+      const errors = new Map();
+      await selfRegistrationFormService.checkDuplicateValue(errors);
+      expect(errors.size).toEqual(0);
+    });
+  });
+});
+
+function mockState(adminSelfRegistrationContext) {
+  const setStateMock = state => {
+    let newState;
+    if (typeof state  === 'function') {
+      newState = state(adminSelfRegistrationContext.state);
+    } else {
+      newState = state;
+    }
+    adminSelfRegistrationContext.state = Object.assign(adminSelfRegistrationContext.state, newState);
+  };
+  jest.spyOn(adminSelfRegistrationContext, "setState").mockImplementation(setStateMock);
+}

package/src/shared/services/forms/userDirectory/UserDirectoryFormService.js

@@ -0,0 +1,118 @@
+/**
+ * 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.0
+ */
+
+import XRegExp from 'xregexp';
+
+/**
+ * Model related to the User Directory form settings
+ */
+class UserDirectoryFormService {
+  /**
+   * Constructor
+   *
+   * @param {context} context
+   * @public
+   */
+  constructor(context, translate) {
+    this.context = context;
+    this.translate = translate;
+  }
+
+  /**
+   * getInstance for singleton pattern
+   * @param {context} context
+   * @public
+   */
+  static getInstance(context, translate) {
+    if (!this.instance) {
+      this.instance = new UserDirectoryFormService(context, translate);
+    }
+    return this.instance;
+  }
+
+  /**
+   * killInstance singleton
+   * @param {context} context
+   * @public
+   */
+  static killInstance() {
+    this.instance = null;
+  }
+
+  /**
+   * Validate the form.
+   * @returns {Promise<boolean>}
+   */
+  async validate() {
+    // Validate the form inputs.
+    const validation = {
+      ...this.validateHostInput(),
+      ...this.validatePortInput(),
+      ...this.validateDomainInput()
+    };
+
+    await this.context.setErrors(validation);
+    //Check if we have errors
+    return Object.values(validation).filter(x => x).length === 0;
+  }
+
+  /**
+   * Validate the host input.
+   * @returns {Promise<void>}
+   */
+  validateHostInput() {
+    const settings = this.context.getSettings();
+    let hostError = null;
+    const host = settings.host.trim();
+    if (!host.length) {
+      hostError = this.translate("A host is required.");
+    }
+    this.context.setError("hostError", hostError);
+    return {hostError};
+  }
+
+  /**
+   * Validate the port input.
+   * @returns {Promise<void>}
+   */
+  validatePortInput() {
+    const settings = this.context.getSettings();
+    let portError = null;
+    const port = settings.port.trim();
+    if (!port.length) {
+      portError = this.translate("A port is required.");
+    } else if (!XRegExp("^[0-9]+").test(port)) {
+      portError = this.translate("Only numeric characters allowed.");
+    }
+    this.context.setError("portError", portError);
+    return {portError};
+  }
+
+  /**
+   * Validate the domain input.
+   * @returns {Promise<void>}
+   */
+  validateDomainInput() {
+    const settings = this.context.getSettings();
+    let domainError = null;
+    const domain = settings.domain.trim();
+    if (!domain.length) {
+      domainError = this.translate("A domain name is required.");
+    }
+    this.context.setError("domainError", domainError);
+    return {domainError};
+  }
+}
+
+export default UserDirectoryFormService;