passbolt-styleguide 3.8.4 → 3.9.0-alpha2

package/src/react-extension/contexts/Administration/AdministrationSelfRegistration/AdministrationSelfRegistrationContext.test.js

@@ -0,0 +1,218 @@
+/**
+ * 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 {mockApiResponse} from '../../../../../test/mocks/mockApiResponse';
+import {defaultProps, mockResult} from '../../../components/Administration/DisplaySelfRegistrationAdministration/DisplaySelfRegistrationAdministration.test.data';
+import {enableFetchMocks} from 'jest-fetch-mock';
+import SelfRegistrationDomainsViewModel from '../../../../shared/models/selfRegistration/SelfRegistrationDomainsViewModel';
+import {AdminSelfRegistrationContextProvider} from "../../../contexts/Administration/AdministrationSelfRegistration/AdministrationSelfRegistrationContext";
+import MapObject from '../../../lib/Map/MapObject';
+import SelfRegistrationDto from '../../../../shared/models/selfRegistration/SelfRegistrationDto';
+import ConfirmSaveSelfRegistrationSettings from '../../../components/Administration/DisplaySelfRegistrationAdministration/ConfirmSaveSelfRegistrationSettings/ConfirmSaveSelfRegistrationSettings';
+import ConfirmDeletionSelfRegistrationSettings from '../../../components/Administration/DisplaySelfRegistrationAdministration/ConfirmDeletionSelfRegistrationSettings/ConfirmDeletionSelfRegistrationSettings';
+import NotifyError from '../../../components/Common/Error/NotifyError/NotifyError';
+import PassboltServiceUnavailableError from '../../../../shared/lib/Error/PassboltServiceUnavailableError';
+
+describe("AdministrationSelfRegistrationContext", () => {
+  let adminSelfRegistrationContext; // The adminSelfRegistrationContext to test
+  const props = defaultProps(); // The props to pass
+
+  const mockApiCalls = () => {
+    fetch.doMockOnceIf(/self-registration\/settings*/, () => mockApiResponse(mockResult()));
+  };
+
+  //Initialize context by default
+  const initContext = async() => {
+    mockApiCalls();
+    await adminSelfRegistrationContext.findSettings();
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    adminSelfRegistrationContext = new AdminSelfRegistrationContextProvider(props);
+    mockState(adminSelfRegistrationContext);
+    enableFetchMocks();
+  });
+
+  describe("AdministrationSelfRegistrationContext::findSettings", () => {
+    it("should get the current settings and store it in its state", async() => {
+      expect.assertions(3);
+
+      // Mock the call to API
+      mockApiCalls();
+      const expectedResult = new SelfRegistrationDomainsViewModel(mockResult());
+      await adminSelfRegistrationContext.findSettings();
+      const domains = adminSelfRegistrationContext.getAllowedDomains();
+      expect(domains.values()).toEqual(expectedResult.allowedDomains.values());
+      expect(adminSelfRegistrationContext.getCurrentSettings()).toEqual(mockResult());
+      expect(adminSelfRegistrationContext.isProcessing()).toBeFalsy();
+    });
+    it("should set processing to true when loading settings", async() => {
+      expect.assertions(1);
+
+      adminSelfRegistrationContext.setProcessing(false);
+      try {
+        await adminSelfRegistrationContext.findSettings();
+      } catch {
+        expect(adminSelfRegistrationContext.isProcessing()).toBeTruthy();
+      }
+    });
+  });
+
+  describe("AdministrationSelfRegistrationContext::hasSettingsChanges", () => {
+    let keys = null;
+
+    beforeEach(async() => {
+      await initContext();
+      keys = MapObject.iterators(adminSelfRegistrationContext.getAllowedDomains());
+    });
+    it("should return true if settings is different then current setting", () => {
+      expect.assertions(1);
+
+      const domains = MapObject.clone(adminSelfRegistrationContext.getAllowedDomains());
+      domains.set(keys[0], "passbot.com");
+      adminSelfRegistrationContext.setDomains({allowedDomains: domains});
+
+      expect(adminSelfRegistrationContext.hasSettingsChanges()).toBeTruthy();
+    });
+
+    it("should return false if settings is different then current setting", () => {
+      expect.assertions(1);
+      const [firstValue] = adminSelfRegistrationContext.getAllowedDomains().values();
+
+      const domains = MapObject.clone(adminSelfRegistrationContext.getAllowedDomains());
+      domains.set(keys[0], "passbot.com");
+      adminSelfRegistrationContext.setDomains({allowedDomains: domains});
+      domains.set(keys[0], firstValue);
+      adminSelfRegistrationContext.setDomains({allowedDomains: domains});
+
+      expect(adminSelfRegistrationContext.hasSettingsChanges()).toBeFalsy();
+    });
+  });
+
+  describe("AdminUserDirectoryContext::clearContext", () => {
+    beforeEach(async() => {
+      await initContext();
+    });
+    it("should clear the context and set it by default", () => {
+      expect.assertions(3);
+
+      adminSelfRegistrationContext.setDomains({allowedDomains: {"test": "value"}});
+      adminSelfRegistrationContext.clearContext();
+
+      expect(adminSelfRegistrationContext.isProcessing()).toBeTruthy();
+      expect(adminSelfRegistrationContext.getCurrentSettings()).toBe(null);
+      expect(adminSelfRegistrationContext.getAllowedDomains()).toEqual(new Map());
+    });
+  });
+
+  describe("AdminUserDirectoryContext::save", () => {
+    beforeEach(async() => {
+      await initContext();
+    });
+    it("should display ConfirmSaveSelfRegistrationSettings if form is valid", async() => {
+      await adminSelfRegistrationContext.save();
+
+      expect.assertions(2);
+
+      expect(adminSelfRegistrationContext.isSubmitted).toBeTruthy();
+      expect(props.dialogContext.open).toHaveBeenCalledWith(ConfirmSaveSelfRegistrationSettings, expect.objectContaining({"domains": adminSelfRegistrationContext.getAllowedDomains()}));
+    });
+
+    it("should display ConfirmDeletionSelfRegistrationSettings if form is valid and domains are empty", async() => {
+      adminSelfRegistrationContext.setDomains({allowedDomains: new Map()});
+      await adminSelfRegistrationContext.save();
+
+      expect.assertions(2);
+
+      expect(adminSelfRegistrationContext.isSubmitted).toBeTruthy();
+      expect(props.dialogContext.open).toHaveBeenCalledWith(ConfirmDeletionSelfRegistrationSettings, expect.objectContaining({onClose: expect.any(Function), onSubmit: expect.any(Function)}));
+    });
+  });
+
+  describe("AdminUserDirectoryContext::saveSettings", () => {
+    beforeEach(async() => {
+      await initContext();
+    });
+    it("should save settings and display feedback", async() => {
+      fetch.doMockOnceIf(/self-registration\/settings*/, () => mockApiResponse({}));
+      jest.spyOn(adminSelfRegistrationContext, "findSettings").mockImplementation();
+
+      await adminSelfRegistrationContext.saveSettings();
+
+      expect.assertions(4);
+
+      //Save should set processing to false in any case
+      expect(adminSelfRegistrationContext.isProcessing()).toBeFalsy();
+      expect(adminSelfRegistrationContext.findSettings).toHaveBeenCalled();
+      expect(props.actionFeedbackContext.displaySuccess).toHaveBeenCalledWith("The self registration settings for the organization were updated.");
+      expect(JSON.parse(fetch.mock.calls[1][1].body)).toEqual(expect.objectContaining(new SelfRegistrationDto({allowedDomains: adminSelfRegistrationContext.getAllowedDomains()}, adminSelfRegistrationContext.getCurrentSettings())));
+    });
+
+    it("should not save settings and display feedback when we have an error", async() => {
+      const error = {message: "The service is unavailable"};
+
+      fetch.doMockOnceIf(/self-registration\/settings*/, () => Promise.reject(error));
+
+      jest.spyOn(adminSelfRegistrationContext, "findSettings").mockImplementation();
+
+      await adminSelfRegistrationContext.saveSettings();
+
+      expect.assertions(4);
+
+      //Save should set processing to false in any case
+      expect(adminSelfRegistrationContext.isProcessing()).toBeFalsy();
+      expect(adminSelfRegistrationContext.findSettings).not.toHaveBeenCalled();
+      expect(props.dialogContext.open).toHaveBeenCalledWith(NotifyError, {"error": new PassboltServiceUnavailableError(error.message)});
+      expect(JSON.parse(fetch.mock.calls[1][1].body)).toEqual(expect.objectContaining(new SelfRegistrationDto({allowedDomains: adminSelfRegistrationContext.getAllowedDomains()}, adminSelfRegistrationContext.getCurrentSettings())));
+    });
+  });
+  describe("AdminMfaContext::errors", () => {
+    it("should update error object with targeted property", async() => {
+      expect.assertions(1);
+      await adminSelfRegistrationContext.setError("uuid1", "error");
+
+      expect(adminSelfRegistrationContext.getErrors().get("uuid1")).toBe("error");
+    });
+
+    it("should init errors with default property", async() => {
+      expect.assertions(1);
+      expect(adminSelfRegistrationContext.getErrors()).toEqual(new Map());
+    });
+  });
+
+  describe("AdminMfaContext::setSubmitted", () => {
+    it("should set submit and focus", async() => {
+      expect.assertions(2);
+      await adminSelfRegistrationContext.setSubmitted(true);
+
+      expect(adminSelfRegistrationContext.isSubmitted()).toBeTruthy();
+      expect(adminSelfRegistrationContext.shouldFocus()).toBeTruthy();
+    });
+  });
+});
+
+
+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/react-extension/contexts/Administration/AdministrationSubscription/AdministrationSubscription.js

@@ -0,0 +1,168 @@
+/**
+ * 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 React from "react";
+import PropTypes from "prop-types";
+import {withAppContext} from "../../AppContext";
+import SubscriptionModel from '../../../../shared/models/subscription/SubscriptionModel';
+
+/**
+ * The Administration Subscription Context
+ * @type {React.Context<Object>}
+ */
+export const AdminSubscriptionContext = React.createContext({
+  getSubscription: () => {}, // Returns settings for UI changes
+  findSubscriptionKey: () => {}, // Find the subscription key
+  isProcessing: () => {}, // returns true if a process is running and the UI must be disabled
+  setProcessing: () => {}, // Set processing state
+  getActiveUsers: () => {}, //get active users numbers
+  clearContext: () => {}, // put the data to its default state value
+});
+
+/**
+ * The Administration Subscription context provider
+ */
+export class AdminSubscriptionContextProvider 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 {
+      subscription: new SubscriptionModel(), // Change done to the subscription object
+      processing: true, // Context is processing data
+      getSubscription: this.getSubscription.bind(this), // Returns settings for UI changes
+      findSubscriptionKey: this.findSubscriptionKey.bind(this), // Find the subscription key
+      isProcessing: this.isProcessing.bind(this), // returns true if a process is running and the UI must be disabled
+      setProcessing: this.setProcessing.bind(this), // Set processing state
+      getActiveUsers: this.getActiveUsers.bind(this), //get active users numbers
+      clearContext: this.clearContext.bind(this), // put the data to its default state value
+    };
+  }
+
+  /**
+   * Find the subscription key
+   * @return {Promise<void>}
+   */
+  async findSubscriptionKey() {
+    this.setProcessing(true);
+    let subscription = new SubscriptionModel();
+    try {
+      const result = await this.props.context.onGetSubscriptionKeyRequested();
+      subscription = new SubscriptionModel(result);
+    } catch (error) {
+      if (error.name === "PassboltSubscriptionError") {
+        subscription = new SubscriptionModel(error.subscription);
+      }
+    } finally {
+      //Init subscription which will interact with UI
+      this.setState({subscription});
+      this.setProcessing(false);
+    }
+  }
+
+  /**
+   * Get active users
+   * @returns {*}
+   * @constructor
+   */
+  async getActiveUsers() {
+    const users = await this.props.context.port.request("passbolt.users.get-all");
+    const filterActiveUsers = user => user.active;
+    return users.filter(filterActiveUsers).length;
+  }
+
+  /**
+   * Returns the subscription that have been fetch previously.
+   * @returns {object}
+   */
+  getSubscription() {
+    return this.state.subscription;
+  }
+
+  /**
+   * Returns true when the data is under processing
+   * @returns {boolean}
+   *
+   */
+  isProcessing() {
+    return this.state.processing;
+  }
+
+  /**
+   * Handle processing change.
+   * @params {Boolean} processing value
+   * @returns {void}
+   */
+  setProcessing(processing) {
+    this.setState({processing});
+  }
+
+  /**
+   * Puts the state to its default in order to avoid keeping the data users didn't want to save.
+   */
+  clearContext() {
+    const {subscription, processing} = this.defaultState;
+    this.setState({
+      subscription, processing
+    });
+  }
+
+  /**
+   * Render the component
+   * @returns {JSX}
+   */
+  render() {
+    return (
+      <AdminSubscriptionContext.Provider value={this.state}>
+        {this.props.children}
+      </AdminSubscriptionContext.Provider>
+    );
+  }
+}
+
+AdminSubscriptionContextProvider.propTypes = {
+  context: PropTypes.any, // The application context
+  children: PropTypes.any, // The children components
+};
+
+export default withAppContext(AdminSubscriptionContextProvider);
+
+
+/**
+ * Resource Workspace Context Consumer HOC
+ * @param WrappedComponent
+ */
+export function withAdminSubscription(WrappedComponent) {
+  return class WithAdminSubscription extends React.Component {
+    render() {
+      return (
+        <AdminSubscriptionContext.Consumer>
+          {
+            adminSubcriptionContext => <WrappedComponent adminSubcriptionContext={adminSubcriptionContext} {...this.props} />
+          }
+        </AdminSubscriptionContext.Consumer>
+      );
+    }
+  };
+}
+

package/src/react-extension/contexts/Administration/AdministrationSubscription/AdministrationSubscription.test.js

@@ -0,0 +1,73 @@
+/**
+ * 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 {defaultProps, mockSubscriptionModel} from "../../../../react-extension/components/Administration/DisplaySubscriptionKey/DisplaySubscriptionKey.test.data";
+import {AdminSubscriptionContextProvider} from "./AdministrationSubscription";
+import PassboltSubscriptionError from '../../../lib/Error/PassboltSubscriptionError';
+
+describe("AdminSubscriptionContext", () => {
+  let adminSubscribeContext; // The adminSubscribeContext to test
+  const props = defaultProps(); // The props to pass
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    adminSubscribeContext = new AdminSubscriptionContextProvider(Object.assign({}, props));
+    const setStateMock = state => adminSubscribeContext.state = Object.assign(adminSubscribeContext.state, state);
+    jest.spyOn(adminSubscribeContext, "setState").mockImplementation(setStateMock);
+  });
+  describe("AdminSubscriptionContext::findSubscriptionKey", () => {
+    it("should get the current subscription and store it in its state", async() => {
+      await adminSubscribeContext.findSubscriptionKey();
+
+      expect.assertions(2);
+
+      expect(adminSubscribeContext.getSubscription()).toEqual(mockSubscriptionModel);
+      expect(adminSubscribeContext.isProcessing()).toBeFalsy();
+    });
+
+    it("should init subscription with error in case of PassboltSubscriptionError", async() => {
+      jest.spyOn(props.context, "onGetSubscriptionKeyRequested").mockImplementation(() => { throw new PassboltSubscriptionError("error", {}); });
+      await adminSubscribeContext.findSubscriptionKey();
+
+      expect.assertions(3);
+      const subscription = adminSubscribeContext.getSubscription();
+      expect(subscription.email).toEqual('N/A');
+      expect(subscription.subscriptionId).toEqual('N/A');
+      expect(adminSubscribeContext.isProcessing()).toBeFalsy();
+    });
+  });
+  describe("AdminSubscriptionContext::hasSettingsChanges", () => {
+    it("should return the number of active user", async() => {
+      const activeUsers = await adminSubscribeContext.getActiveUsers();
+
+      expect.assertions(1);
+
+      expect(activeUsers).toEqual(5);
+    });
+  });
+
+  describe("AdminSubscriptionContext::clearContext", () => {
+    it("should clear the context and set it by default", async() => {
+      await adminSubscribeContext.findSubscriptionKey();
+      adminSubscribeContext.clearContext();
+
+      expect.assertions(2);
+
+      expect(adminSubscribeContext.isProcessing()).toBeTruthy();
+      expect(adminSubscribeContext.getSubscription().subscriptionId).toEqual("");
+    });
+  });
+});
+
+