@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/node/mocks/auth-mocks/profileActions.mocks.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _ProfileState = require("../../auth/ProfileState");
+var _helpers = require("../../helpers");
+var _dummy = require("../dummy");
+var _helpers2 = require("../helpers");
+const _excluded = ["callback", "profilePictureUrl"];
+var _default = (store, api, actions) => {
+  const originalActions = (0, _ProfileState.buildProfileActions)(store, api, actions);
+  const mockedActions = (0, _helpers2.mockActionsExpect)(originalActions, ['setProfileState', 'resetProfileState']);
+  mockedActions.loadProfile = async () => {
+    mockedActions.setProfileState({
+      loading: true
+    });
+    await (0, _helpers.delay)();
+    actions.setUser((0, _extends2.default)({}, _dummy.userDemo, _dummy.userProfileDemo));
+    mockedActions.setProfileState({
+      loading: false,
+      profile: _dummy.userProfileDemo
+    });
+  };
+  mockedActions.saveProfile = async _payload => {
+    const {
+        callback,
+        profilePictureUrl
+      } = _payload,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_payload, _excluded);
+    mockedActions.setProfileState({
+      saving: true,
+      error: null
+    });
+    const oldProfileData = _dummy.profileStateDemo;
+    let newProfilePictureUrl = oldProfileData.profile.profilePictureUrl;
+    if (profilePictureUrl !== oldProfileData.profile.profilePictureUrl && profilePictureUrl) {
+      const matchResult = (profilePictureUrl || '').match(/^data:image\/([A-Za-z-+\/]+);base64,(.+)$/);
+      if (matchResult) {
+        newProfilePictureUrl = profilePictureUrl;
+      }
+    }
+    const newProfileData = (0, _extends2.default)({}, oldProfileData.profile, payload, {
+      profilePictureUrl: newProfilePictureUrl
+    });
+    const currentUser = _dummy.userDemo;
+    await (0, _helpers.delay)();
+    actions.setUser((0, _extends2.default)({}, currentUser, newProfileData));
+    mockedActions.setProfileState({
+      loading: false,
+      error: null,
+      saving: false,
+      profile: newProfileData
+    });
+    callback == null ? void 0 : callback(newProfileData);
+  };
+  mockedActions.changePassword = async payload => {
+    var _payload$callback;
+    mockedActions.setProfileState({
+      loading: true
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setProfileState({
+      loading: false,
+      error: undefined
+    });
+    (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+  };
+  return mockedActions;
+};
+exports.default = _default;

package/node/mocks/auth-mocks/provisioningActions.mocks.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helpers = require("../helpers");
+var _ProvisioningState = require("../../auth/ProvisioningState");
+var _default = (store, api, actions) => {
+  const originalActions = (0, _ProvisioningState.buildProvisioningActions)(store, api, actions);
+  return (0, _helpers.mockActionsExpect)(originalActions, ['setProvisioningState', 'resetProvisioningState']);
+};
+exports.default = _default;

package/node/mocks/auth-mocks/resetPhoneNumberActions.mocks.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helpers = require("../helpers");
+var _ResetPhoneNumberState = require("../../auth/ResetPhoneNumberState");
+var _default = (store, api, actions) => {
+  const originalActions = (0, _ResetPhoneNumberState.buildResetPhoneNumberActions)(store, api, actions);
+  return (0, _helpers.mockActionsExpect)(originalActions, ['setResetPhoneNumberState', 'resetResetPhoneNumberState']);
+};
+exports.default = _default;

package/node/mocks/auth-mocks/rolesActions.mocks.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _auth = require("../../auth");
+var _helpers = require("../../helpers");
+var _RolesState = require("../../auth/RolesState");
+var _dummy = require("../dummy");
+var _helpers2 = require("../helpers");
+var _default = (store, api, actions) => {
+  const originalActions = (0, _RolesState.buildRolesActions)(store, api, actions);
+  const mockedActions = (0, _helpers2.mockActionsExpect)(originalActions, ['setRolesState', 'setRolesStateError', 'setRolesStateLoader', 'resetRolesState']);
+  mockedActions.loadRolesAndPermissions = async payload => {
+    var _payload$silentLoadin;
+    const key = _auth.RolesStateKeys.LOAD_ROLES;
+    mockedActions.setRolesStateLoader({
+      key,
+      value: !((_payload$silentLoadin = payload == null ? void 0 : payload.silentLoading) != null ? _payload$silentLoadin : false)
+    });
+    try {
+      mockedActions.setRolesState({
+        roles: _dummy.rolesAdminViewerDemo
+      });
+    } catch (e) {
+      mockedActions.setRolesStateError({
+        key,
+        value: (0, _helpers.errorHandler)(e)
+      });
+    } finally {
+      mockedActions.setRolesStateLoader({
+        key,
+        value: false
+      });
+    }
+  };
+  return mockedActions;
+};
+exports.default = _default;

package/node/mocks/auth-mocks/security/restrictionsActions.mocks.js

@@ -0,0 +1,256 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _RestrictionsState = require("../../../auth/Security/RestrictionsState");
+var _restApi = require("@frontegg/rest-api");
+var _helpers = require("../../../helpers");
+var _dummy = require("../../dummy");
+var _uuid = require("uuid");
+var _helpers2 = require("../../helpers");
+const _excluded = ["callback"],
+  _excluded2 = ["callback"],
+  _excluded3 = ["callback"],
+  _excluded4 = ["callback"];
+var _default = (store, api, actions) => {
+  const originalActions = (0, _RestrictionsState.buildRestrictionsActions)(store, api, actions);
+  const mockedActions = (0, _helpers2.mockActionsExpect)(originalActions, ['setRestrictionsState', 'setIpRestrictionsState', 'setEmailDomainRestrictionsState']);
+  mockedActions.loadIpRestrictions = async () => {
+    mockedActions.setIpRestrictionsState({
+      loading: true,
+      error: null
+    });
+    mockedActions.setIpRestrictionsState({
+      data: {
+        restrictions: _dummy.dummyIps.filter(ip => ip.strategy === _dummy.dummyIpConfig.strategy),
+        config: _dummy.dummyIpConfig
+      },
+      totalPages: 1,
+      pagination: {
+        _filter: _restApi.RestrictionType.ALLOW,
+        _limit: 50,
+        _offset: 0
+      },
+      loading: false
+    });
+  };
+  mockedActions.loadEmailDomainRestrictions = async () => {
+    mockedActions.setEmailDomainRestrictionsState({
+      loading: true,
+      error: null
+    });
+    mockedActions.setEmailDomainRestrictionsState({
+      loading: false,
+      data: {
+        restrictions: [{
+          domain: 'mock.com',
+          id: '1',
+          type: _restApi.RestrictionType.ALLOW
+        }],
+        config: {
+          active: true,
+          listType: _restApi.RestrictionType.ALLOW,
+          blockPublicDomains: false
+        }
+      }
+    });
+  };
+  mockedActions.saveIpRestriction = async payload => {
+    var _ipRestrictionsState$, _ipRestrictionsState$2, _newRestriction$isAct;
+    const {
+        callback
+      } = payload,
+      newRestriction = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded);
+    mockedActions.setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    const ipRestrictionsState = store.auth.restrictionsState.ipRestrictions;
+    const filteredRestrictions = ipRestrictionsState.data.restrictions.filter(r => r.ip !== newRestriction.ip);
+    mockedActions.setIpRestrictionsState({
+      data: {
+        config: (_ipRestrictionsState$ = (_ipRestrictionsState$2 = ipRestrictionsState.data) == null ? void 0 : _ipRestrictionsState$2.config) != null ? _ipRestrictionsState$ : {
+          isActive: false,
+          strategy: _restApi.RestrictionType.ALLOW
+        },
+        restrictions: [...filteredRestrictions, (0, _extends2.default)({}, newRestriction, {
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          id: (0, _uuid.v4)(),
+          isActive: (_newRestriction$isAct = newRestriction.isActive) != null ? _newRestriction$isAct : true,
+          strategy: ipRestrictionsState.data.config.strategy
+        })]
+      },
+      totalPages: 1,
+      pagination: {
+        _filter: _restApi.RestrictionType.ALLOW,
+        _limit: 50,
+        _offset: 0
+      },
+      saving: false
+    });
+    callback == null ? void 0 : callback(true);
+  };
+  mockedActions.saveIpRestrictionsConfig = async payload => {
+    var _ipRestrictionsState$3, _ipRestrictionsState$4, _ipRestrictionsState$5;
+    const {
+        callback
+      } = payload,
+      config = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded2);
+    const ipRestrictionsState = store.auth.restrictionsState.ipRestrictions;
+    mockedActions.setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    mockedActions.setIpRestrictionsState({
+      data: {
+        config: (0, _extends2.default)({}, (_ipRestrictionsState$3 = ipRestrictionsState.data) == null ? void 0 : _ipRestrictionsState$3.config, config),
+        restrictions: (_ipRestrictionsState$4 = (_ipRestrictionsState$5 = ipRestrictionsState.data) == null ? void 0 : _ipRestrictionsState$5.restrictions) != null ? _ipRestrictionsState$4 : []
+      },
+      pagination: {
+        _filter: _restApi.RestrictionType.ALLOW,
+        _limit: 50,
+        _offset: 0
+      },
+      totalPages: 1,
+      saving: false
+    });
+    mockedActions.setIpRestrictionsState({
+      saving: false,
+      error: null
+    });
+    callback == null ? void 0 : callback(true);
+  };
+  mockedActions.deleteIpRestriction = async payload => {
+    var _ipRestrictionsState$6;
+    const {
+      callback,
+      id
+    } = payload;
+    mockedActions.setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    const ipRestrictionsState = store.auth.restrictionsState.ipRestrictions;
+    mockedActions.setIpRestrictionsState({
+      data: {
+        config: ((_ipRestrictionsState$6 = ipRestrictionsState.data) == null ? void 0 : _ipRestrictionsState$6.config) || {
+          isActive: false,
+          strategy: _restApi.RestrictionType.ALLOW
+        },
+        restrictions: ipRestrictionsState.data.restrictions.filter(ip => ip.id !== id)
+      },
+      pagination: {
+        _filter: _restApi.RestrictionType.ALLOW,
+        _limit: 50,
+        _offset: 0
+      },
+      totalPages: 1,
+      saving: false,
+      error: null
+    });
+    callback == null ? void 0 : callback(true);
+  };
+  mockedActions.checkIfUserIpValid = async () => {
+    mockedActions.setIpRestrictionsState({
+      loading: true,
+      error: null
+    });
+    try {
+      const ipRestrictionState = store.auth.restrictionsState.ipRestrictions;
+      const userIp = _dummy.dummyIps[0].ip;
+      const userIpValid = !!ipRestrictionState.data.restrictions.find(restriction => restriction.isActive && restriction.ip === userIp);
+      mockedActions.setIpRestrictionsState({
+        userIpValid,
+        loading: false
+      });
+    } catch (e) {
+      mockedActions.setIpRestrictionsState({
+        error: (0, _helpers.errorHandler)(e),
+        loading: false
+      });
+    }
+  };
+  mockedActions.saveEmailDomainRestriction = async payload => {
+    var _emailDomainRestricti, _emailDomainRestricti2;
+    const {
+        callback
+      } = payload,
+      restriction = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded3);
+    const emailDomainRestrictionsState = store.auth.restrictionsState.emailDomainRestrictions;
+    mockedActions.setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    callback == null ? void 0 : callback(true);
+    mockedActions.setEmailDomainRestrictionsState({
+      data: {
+        config: ((_emailDomainRestricti = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti.config) || {
+          active: false,
+          blockPublicDomains: false,
+          listType: restriction.type
+        },
+        restrictions: [...(((_emailDomainRestricti2 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti2.restrictions) || []), (0, _extends2.default)({}, restriction, {
+          id: Date.now().toString()
+        })]
+      },
+      saving: false
+    });
+  };
+  mockedActions.saveEmailDomainRestrictionsConfig = async payload => {
+    var _emailDomainRestricti3;
+    const {
+        callback
+      } = payload,
+      config = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded4);
+    const emailDomainRestrictionsState = store.auth.restrictionsState.emailDomainRestrictions;
+    mockedActions.setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    callback == null ? void 0 : callback(true);
+    mockedActions.setEmailDomainRestrictionsState({
+      data: {
+        config: {
+          active: config.active,
+          blockPublicDomains: config.blockPublicDomains || false,
+          listType: config.type || _restApi.RestrictionType.ALLOW
+        },
+        restrictions: [...(((_emailDomainRestricti3 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti3.restrictions) || [])]
+      },
+      saving: false
+    });
+  };
+  mockedActions.deleteEmailDomainRestriction = async payload => {
+    var _emailDomainRestricti4, _emailDomainRestricti5;
+    const {
+      id
+    } = payload;
+    const emailDomainRestrictionsState = store.auth.restrictionsState.emailDomainRestrictions;
+    mockedActions.setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setEmailDomainRestrictionsState({
+      data: {
+        config: ((_emailDomainRestricti4 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti4.config) || {
+          active: false,
+          blockPublicDomains: false,
+          listType: _restApi.RestrictionType.ALLOW
+        },
+        restrictions: (((_emailDomainRestricti5 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti5.restrictions) || []).filter(restriction => restriction.id === id)
+      },
+      saving: false
+    });
+  };
+  return mockedActions;
+};
+exports.default = _default;

package/node/mocks/auth-mocks/security/securityCenterActions.mocks.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _SecurityCenterState = require("../../../auth/Security/SecurityCenterState");
+var _auth = require("../../../auth");
+var _helpers = require("../../../helpers");
+var _dummy = require("../../dummy");
+var _helpers2 = require("../../helpers");
+var _default = (store, api, actions) => {
+  const originalActions = (0, _SecurityCenterState.buildSecurityCenterActions)(store, api, actions);
+  const mockedActions = (0, _helpers2.mockActionsExpect)(originalActions, ['setSecurityCenterState', 'setSecurityCenterStateError', 'setSecurityCenterStateLoader', 'resetSecurityCenterState']);
+  mockedActions.loadRecommendations = async () => {
+    const key = _auth.SecurityCenterStateKeys.RECOMMENDATIONS;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityCenterState({
+      recommendations: _dummy.securityCenterRecommendationsMock.recommendations.items,
+      score: _dummy.securityCenterRecommendationsMock.scoring.score
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadInsights = async () => {
+    const key = _auth.SecurityCenterStateKeys.INSIGHTS;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityCenterState({
+      insights: _dummy.securityCenterInsightsMock.insights.items
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadBreachedPasswordUsers = async () => {
+    const key = _auth.SecurityCenterStateKeys.BREACHED_PASSWORD_USERS_TABLE;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityCenterState({
+      breachedPasswordUsersTable: _dummy.securityCenterBreachedPasswordUsersMock
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadUnenrolledMfaUsers = async () => {
+    const key = _auth.SecurityCenterStateKeys.UNENROLLED_MFA_USERS_TABLE;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityCenterState({
+      unenrolledMfaUsersTable: _dummy.securityCenterUnenrolledMfaUsersMock
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadInactiveUsers = async () => {
+    const key = _auth.SecurityCenterStateKeys.INACTIVE_USERS_TABLE;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityCenterState({
+      inactiveUsersTable: _dummy.securityCenterInactivityPasswordUsersMock
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.sendResetBreachedPasswordEmail = async payload => {
+    const {
+      callback
+    } = payload;
+    const key = _auth.SecurityCenterStateKeys.SEND_BREACHED_PASSWORD_EMAIL;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await (0, _helpers.delay)();
+    callback == null ? void 0 : callback(true);
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  return mockedActions;
+};
+exports.default = _default;

package/node/mocks/auth-mocks/security/securityPolicyActions.mocks.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _SecurityPolicyState = require("../../../auth/Security/SecurityPolicyState");
+var _helpers = require("../../../helpers");
+var _dummy = require("../../dummy");
+var _helpers2 = require("../../helpers");
+const _excluded = ["callback"],
+  _excluded2 = ["callback"],
+  _excluded3 = ["callback"];
+var _default = (store, api, actions) => {
+  const originalActions = (0, _SecurityPolicyState.buildSecurityPolicyActions)(store, api, actions);
+  const mockedActions = (0, _helpers2.mockActionsExpect)(originalActions, ['setSecurityPolicyState', 'setSecurityPolicyGlobalState', 'setSecurityPolicyPublicState', 'setSecurityPolicyMfaState', 'setSecurityPolicyVendorMfaState', 'setSecurityPolicyLockoutState', 'setSecurityPolicyVendorLockoutState', 'setSecurityPolicyCaptchaState', 'setSecurityPolicyPasswordHistoryState', 'setSecurityPolicyVendorPasswordHistoryState', 'resetSecurityPolicyState', 'setSecurityPolicyPasswordState', 'setSecurityPolicyAuthStrategyPublicState']);
+  mockedActions.loadSecurityPolicy = async () => {
+    mockedActions.setSecurityPolicyGlobalState({
+      loading: true,
+      error: null
+    });
+    await Promise.all([mockedActions.loadSecurityPolicyMfa(), mockedActions.loadSecurityPolicyVendorMfa(), mockedActions.loadSecurityPolicyLockout(), mockedActions.loadSecurityPolicyVendorLockout(), mockedActions.loadSecurityPolicyPasswordHistory(), mockedActions.loadSecurityPolicyVendorPasswordHistory(), mockedActions.loadSecurityPolicyCaptcha()]);
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyGlobalState({
+      policy: _dummy.policyDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadPublicSecurityPolicy = async () => {
+    mockedActions.setSecurityPolicyPublicState({
+      loading: true,
+      error: null
+    });
+    try {
+      mockedActions.setSecurityPolicyPublicState({
+        policy: _dummy.publicSecurityPolicy,
+        loading: false
+      });
+    } catch (e) {
+      mockedActions.setSecurityPolicyPublicState({
+        error: (0, _helpers.errorHandler)(e),
+        loading: false
+      });
+    }
+  };
+  mockedActions.saveSecurityPolicyMfa = async payload => {
+    var _newSecurityPolicy$id;
+    const {
+        callback
+      } = payload,
+      newSecurityPolicy = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded);
+    mockedActions.setSecurityPolicyMfaState({
+      saving: true,
+      error: null
+    });
+    const policy = (0, _extends2.default)({}, _dummy.policyLockoutDemo, {
+      id: (_newSecurityPolicy$id = newSecurityPolicy.id) != null ? _newSecurityPolicy$id : _dummy.policyLockoutDemo.id,
+      enforceMFAType: newSecurityPolicy.enforceMFAType
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyMfaState({
+      policy,
+      saving: false
+    });
+    callback == null ? void 0 : callback(policy);
+  };
+  mockedActions.loadSecurityPolicyMfa = async () => {
+    mockedActions.setSecurityPolicyMfaState({
+      loading: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyMfaState({
+      policy: _dummy.policyMfaDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyVendorMfa = async () => {
+    mockedActions.setSecurityPolicyVendorMfaState({
+      loading: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyVendorMfaState({
+      policy: _dummy.policyMfaDemo,
+      loading: false
+    });
+  };
+  mockedActions.saveSecurityPolicyLockout = async payload => {
+    const {
+        callback
+      } = payload,
+      newSecurityPolicy = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded2);
+    mockedActions.setSecurityPolicyLockoutState({
+      saving: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    const policy = (0, _extends2.default)({}, _dummy.policyLockoutDemo, newSecurityPolicy, {
+      id: newSecurityPolicy.id ? newSecurityPolicy.id : _dummy.policyLockoutDemo.id
+    });
+    callback == null ? void 0 : callback(policy);
+    mockedActions.setSecurityPolicyLockoutState({
+      policy,
+      saving: false
+    });
+  };
+  mockedActions.loadSecurityPolicyLockout = async () => {
+    mockedActions.setSecurityPolicyLockoutState({
+      loading: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyLockoutState({
+      policy: _dummy.policyLockoutDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyVendorLockout = async () => {
+    mockedActions.setSecurityPolicyVendorLockoutState({
+      loading: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyVendorLockoutState({
+      policy: _dummy.policyLockoutDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyCaptcha = async () => {
+    mockedActions.setSecurityPolicyLockoutState({
+      loading: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyLockoutState({
+      policy: _dummy.policyLockoutDemo,
+      loading: false
+    });
+  };
+  mockedActions.saveSecurityPolicyPasswordHistory = async payload => {
+    const {
+        callback
+      } = payload,
+      newSecurityPolicy = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded3);
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      saving: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    const policy = (0, _extends2.default)({}, _dummy.policyPasswordHistoryDemo, newSecurityPolicy, {
+      id: newSecurityPolicy.id ? newSecurityPolicy.id : _dummy.policyPasswordHistoryDemo.id
+    });
+    callback == null ? void 0 : callback(policy);
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      policy,
+      saving: false
+    });
+  };
+  mockedActions.loadSecurityPolicyPasswordHistory = async () => {
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      loading: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      policy: _dummy.policyPasswordHistoryDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyVendorPasswordHistory = async () => {
+    mockedActions.setSecurityPolicyVendorPasswordHistoryState({
+      loading: true,
+      error: null
+    });
+    await (0, _helpers.delay)();
+    mockedActions.setSecurityPolicyVendorPasswordHistoryState({
+      policy: _dummy.policyPasswordHistoryDemo,
+      loading: false
+    });
+  };
+  return mockedActions;
+};
+exports.default = _default;