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

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

@@ -0,0 +1,248 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback"],
+  _excluded3 = ["callback"],
+  _excluded4 = ["callback"];
+import { buildRestrictionsActions } from '../../../auth/Security/RestrictionsState';
+import { RestrictionType } from '@frontegg/rest-api';
+import { delay, errorHandler } from '../../../helpers';
+import { dummyIpConfig, dummyIps } from '../../dummy';
+import { v4 as uuid } from 'uuid';
+import { mockActionsExpect } from '../../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildRestrictionsActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setRestrictionsState', 'setIpRestrictionsState', 'setEmailDomainRestrictionsState']);
+  mockedActions.loadIpRestrictions = async () => {
+    mockedActions.setIpRestrictionsState({
+      loading: true,
+      error: null
+    });
+    mockedActions.setIpRestrictionsState({
+      data: {
+        restrictions: dummyIps.filter(ip => ip.strategy === dummyIpConfig.strategy),
+        config: dummyIpConfig
+      },
+      totalPages: 1,
+      pagination: {
+        _filter: 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: RestrictionType.ALLOW
+        }],
+        config: {
+          active: true,
+          listType: RestrictionType.ALLOW,
+          blockPublicDomains: false
+        }
+      }
+    });
+  };
+  mockedActions.saveIpRestriction = async payload => {
+    var _ipRestrictionsState$, _ipRestrictionsState$2, _newRestriction$isAct;
+    const {
+        callback
+      } = payload,
+      newRestriction = _objectWithoutPropertiesLoose(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: RestrictionType.ALLOW
+        },
+        restrictions: [...filteredRestrictions, _extends({}, newRestriction, {
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          id: uuid(),
+          isActive: (_newRestriction$isAct = newRestriction.isActive) != null ? _newRestriction$isAct : true,
+          strategy: ipRestrictionsState.data.config.strategy
+        })]
+      },
+      totalPages: 1,
+      pagination: {
+        _filter: 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 = _objectWithoutPropertiesLoose(payload, _excluded2);
+    const ipRestrictionsState = store.auth.restrictionsState.ipRestrictions;
+    mockedActions.setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    mockedActions.setIpRestrictionsState({
+      data: {
+        config: _extends({}, (_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: 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: RestrictionType.ALLOW
+        },
+        restrictions: ipRestrictionsState.data.restrictions.filter(ip => ip.id !== id)
+      },
+      pagination: {
+        _filter: 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 = 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: errorHandler(e),
+        loading: false
+      });
+    }
+  };
+  mockedActions.saveEmailDomainRestriction = async payload => {
+    var _emailDomainRestricti, _emailDomainRestricti2;
+    const {
+        callback
+      } = payload,
+      restriction = _objectWithoutPropertiesLoose(payload, _excluded3);
+    const emailDomainRestrictionsState = store.auth.restrictionsState.emailDomainRestrictions;
+    mockedActions.setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    await 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) || []), _extends({}, restriction, {
+          id: Date.now().toString()
+        })]
+      },
+      saving: false
+    });
+  };
+  mockedActions.saveEmailDomainRestrictionsConfig = async payload => {
+    var _emailDomainRestricti3;
+    const {
+        callback
+      } = payload,
+      config = _objectWithoutPropertiesLoose(payload, _excluded4);
+    const emailDomainRestrictionsState = store.auth.restrictionsState.emailDomainRestrictions;
+    mockedActions.setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    await delay();
+    callback == null ? void 0 : callback(true);
+    mockedActions.setEmailDomainRestrictionsState({
+      data: {
+        config: {
+          active: config.active,
+          blockPublicDomains: config.blockPublicDomains || false,
+          listType: config.type || 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 delay();
+    mockedActions.setEmailDomainRestrictionsState({
+      data: {
+        config: ((_emailDomainRestricti4 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti4.config) || {
+          active: false,
+          blockPublicDomains: false,
+          listType: RestrictionType.ALLOW
+        },
+        restrictions: (((_emailDomainRestricti5 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti5.restrictions) || []).filter(restriction => restriction.id === id)
+      },
+      saving: false
+    });
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/security/securityCenterActions.mocks.d.ts

@@ -0,0 +1,16 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+import { IForgotPassword } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setSecurityCenterState: (state: Partial<import("../../../auth").SecurityCenterState>) => void;
+    resetSecurityCenterState: () => void;
+    setSecurityCenterStateLoader: (payload: import("../../../auth").SecurityCenterStateIndicator) => void;
+    setSecurityCenterStateError: (payload: import("../../../auth").SecurityCenterStateIndicator) => void;
+    loadRecommendations: () => Promise<void>;
+    loadInsights: () => Promise<void>;
+    sendResetBreachedPasswordEmail: (_payload: WithCallback<IForgotPassword, boolean>) => Promise<void>;
+    sendBulkResetBreachedPasswordEmails: (payload: WithCallback<object, boolean>) => Promise<void>;
+    loadBreachedPasswordUsers: (payload: import("@frontegg/rest-api").ISearchUserQueryParamsV3) => Promise<void>;
+    loadUnenrolledMfaUsers: (payload: import("@frontegg/rest-api").ISearchUserQueryParamsV3) => Promise<void>;
+    loadInactiveUsers: (payload: import("@frontegg/rest-api").ISearchUserQueryParamsV3) => Promise<void>;
+};
+export default _default;

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

@@ -0,0 +1,102 @@
+import { buildSecurityCenterActions } from '../../../auth/Security/SecurityCenterState';
+import { SecurityCenterStateKeys } from '../../../auth';
+import { delay } from '../../../helpers';
+import { securityCenterBreachedPasswordUsersMock, securityCenterInactivityPasswordUsersMock, securityCenterInsightsMock, securityCenterRecommendationsMock, securityCenterUnenrolledMfaUsersMock } from '../../dummy';
+import { mockActionsExpect } from '../../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildSecurityCenterActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setSecurityCenterState', 'setSecurityCenterStateError', 'setSecurityCenterStateLoader', 'resetSecurityCenterState']);
+  mockedActions.loadRecommendations = async () => {
+    const key = SecurityCenterStateKeys.RECOMMENDATIONS;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await delay();
+    mockedActions.setSecurityCenterState({
+      recommendations: securityCenterRecommendationsMock.recommendations.items,
+      score: securityCenterRecommendationsMock.scoring.score
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadInsights = async () => {
+    const key = SecurityCenterStateKeys.INSIGHTS;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await delay();
+    mockedActions.setSecurityCenterState({
+      insights: securityCenterInsightsMock.insights.items
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadBreachedPasswordUsers = async () => {
+    const key = SecurityCenterStateKeys.BREACHED_PASSWORD_USERS_TABLE;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await delay();
+    mockedActions.setSecurityCenterState({
+      breachedPasswordUsersTable: securityCenterBreachedPasswordUsersMock
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadUnenrolledMfaUsers = async () => {
+    const key = SecurityCenterStateKeys.UNENROLLED_MFA_USERS_TABLE;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await delay();
+    mockedActions.setSecurityCenterState({
+      unenrolledMfaUsersTable: securityCenterUnenrolledMfaUsersMock
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.loadInactiveUsers = async () => {
+    const key = SecurityCenterStateKeys.INACTIVE_USERS_TABLE;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await delay();
+    mockedActions.setSecurityCenterState({
+      inactiveUsersTable: securityCenterInactivityPasswordUsersMock
+    });
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  mockedActions.sendResetBreachedPasswordEmail = async payload => {
+    const {
+      callback
+    } = payload;
+    const key = SecurityCenterStateKeys.SEND_BREACHED_PASSWORD_EMAIL;
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: true
+    });
+    await delay();
+    callback == null ? void 0 : callback(true);
+    mockedActions.setSecurityCenterStateLoader({
+      key,
+      value: false
+    });
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/security/securityPolicyActions.mocks.d.ts

@@ -0,0 +1,56 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+import { ISecurityPolicyLockout, ISecurityPolicyMfa, ISecurityPolicyPasswordHistory } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setSecurityPolicyState: (state: Partial<import("../../../auth").SecurityPolicyState>) => void;
+    setSecurityPolicyGlobalState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: import("@frontegg/rest-api").ISecurityPolicy | undefined;
+    }>) => void;
+    setSecurityPolicyPublicState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: import("@frontegg/rest-api").IVendorConfig | undefined;
+    }>) => void;
+    setSecurityPolicyMfaState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: ISecurityPolicyMfa | undefined;
+    }>) => void;
+    setSecurityPolicyVendorMfaState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: ISecurityPolicyMfa | undefined;
+    }>) => void;
+    setSecurityPolicyLockoutState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: ISecurityPolicyLockout | undefined;
+    }>) => void;
+    setSecurityPolicyVendorLockoutState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: ISecurityPolicyLockout | undefined;
+    }>) => void;
+    setSecurityPolicyCaptchaState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: import("@frontegg/rest-api").ISecurityPolicyCaptcha | null | undefined;
+    }>) => void;
+    setSecurityPolicyPasswordHistoryState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: ISecurityPolicyPasswordHistory | undefined;
+    }>) => void;
+    setSecurityPolicyVendorPasswordHistoryState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: ISecurityPolicyPasswordHistory | undefined;
+    }>) => void;
+    resetSecurityPolicyState: () => void;
+    setSecurityPolicyPasswordState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: Partial<import("@frontegg/rest-api").TestConfig> | undefined;
+    }>) => void;
+    setSecurityPolicyAuthStrategyPublicState: (state: Partial<import("../../../interfaces").WithStatus & {
+        policy?: import("@frontegg/rest-api").IAuthStrategiesConfig | undefined;
+    }>) => void;
+    loadSecurityPolicy: () => Promise<void>;
+    loadGlobalSecurityPolicy: () => Promise<void>;
+    loadPublicSecurityPolicy: () => Promise<void>;
+    loadVendorPasswordConfig: () => Promise<void>;
+    loadSecurityPolicyMfa: () => Promise<void>;
+    loadSecurityPolicyVendorMfa: () => Promise<void>;
+    loadSecurityPolicyLockout: () => Promise<void>;
+    loadSecurityPolicyVendorLockout: () => Promise<void>;
+    loadSecurityPolicyCaptcha: () => Promise<void>;
+    loadSecurityPolicyPasswordHistory: () => Promise<void>;
+    loadSecurityPolicyVendorPasswordHistory: () => Promise<void>;
+    loadPublicAuthStrategiesPolicy: () => Promise<void>;
+    saveSecurityPolicyMfa: (payload: import("../../../interfaces").WithCallback<import("@frontegg/rest-api").ISaveSecurityPolicyMfa, ISecurityPolicyMfa>) => Promise<void>;
+    saveSecurityPolicyLockout: (payload: import("../../../interfaces").WithCallback<import("@frontegg/rest-api").ISaveSecurityPolicyLockout, ISecurityPolicyLockout>) => Promise<void>;
+    saveSecurityPolicyPasswordHistory: (payload: import("../../../interfaces").WithCallback<import("@frontegg/rest-api").ISaveSecurityPolicyPasswordHistory, ISecurityPolicyPasswordHistory>) => Promise<void>;
+    __getSecurityPolicyPublicStateWithCustomLogin: (securityPolicyPublicState?: import("@frontegg/rest-api").IVendorConfig | undefined) => Promise<import("@frontegg/rest-api").IVendorConfig | undefined>;
+};
+export default _default;

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

@@ -0,0 +1,179 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback"],
+  _excluded3 = ["callback"];
+import { buildSecurityPolicyActions } from '../../../auth/Security/SecurityPolicyState';
+import { delay, errorHandler } from '../../../helpers';
+import { policyDemo, policyLockoutDemo, policyMfaDemo, policyPasswordHistoryDemo, publicSecurityPolicy } from '../../dummy';
+import { mockActionsExpect } from '../../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildSecurityPolicyActions(store, api, actions);
+  const mockedActions = 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 delay();
+    mockedActions.setSecurityPolicyGlobalState({
+      policy: policyDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadPublicSecurityPolicy = async () => {
+    mockedActions.setSecurityPolicyPublicState({
+      loading: true,
+      error: null
+    });
+    try {
+      mockedActions.setSecurityPolicyPublicState({
+        policy: publicSecurityPolicy,
+        loading: false
+      });
+    } catch (e) {
+      mockedActions.setSecurityPolicyPublicState({
+        error: errorHandler(e),
+        loading: false
+      });
+    }
+  };
+  mockedActions.saveSecurityPolicyMfa = async payload => {
+    var _newSecurityPolicy$id;
+    const {
+        callback
+      } = payload,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(payload, _excluded);
+    mockedActions.setSecurityPolicyMfaState({
+      saving: true,
+      error: null
+    });
+    const policy = _extends({}, policyLockoutDemo, {
+      id: (_newSecurityPolicy$id = newSecurityPolicy.id) != null ? _newSecurityPolicy$id : policyLockoutDemo.id,
+      enforceMFAType: newSecurityPolicy.enforceMFAType
+    });
+    await delay();
+    mockedActions.setSecurityPolicyMfaState({
+      policy,
+      saving: false
+    });
+    callback == null ? void 0 : callback(policy);
+  };
+  mockedActions.loadSecurityPolicyMfa = async () => {
+    mockedActions.setSecurityPolicyMfaState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setSecurityPolicyMfaState({
+      policy: policyMfaDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyVendorMfa = async () => {
+    mockedActions.setSecurityPolicyVendorMfaState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setSecurityPolicyVendorMfaState({
+      policy: policyMfaDemo,
+      loading: false
+    });
+  };
+  mockedActions.saveSecurityPolicyLockout = async payload => {
+    const {
+        callback
+      } = payload,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(payload, _excluded2);
+    mockedActions.setSecurityPolicyLockoutState({
+      saving: true,
+      error: null
+    });
+    await delay();
+    const policy = _extends({}, policyLockoutDemo, newSecurityPolicy, {
+      id: newSecurityPolicy.id ? newSecurityPolicy.id : policyLockoutDemo.id
+    });
+    callback == null ? void 0 : callback(policy);
+    mockedActions.setSecurityPolicyLockoutState({
+      policy,
+      saving: false
+    });
+  };
+  mockedActions.loadSecurityPolicyLockout = async () => {
+    mockedActions.setSecurityPolicyLockoutState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setSecurityPolicyLockoutState({
+      policy: policyLockoutDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyVendorLockout = async () => {
+    mockedActions.setSecurityPolicyVendorLockoutState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setSecurityPolicyVendorLockoutState({
+      policy: policyLockoutDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyCaptcha = async () => {
+    mockedActions.setSecurityPolicyLockoutState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setSecurityPolicyLockoutState({
+      policy: policyLockoutDemo,
+      loading: false
+    });
+  };
+  mockedActions.saveSecurityPolicyPasswordHistory = async payload => {
+    const {
+        callback
+      } = payload,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(payload, _excluded3);
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      saving: true,
+      error: null
+    });
+    await delay();
+    const policy = _extends({}, policyPasswordHistoryDemo, newSecurityPolicy, {
+      id: newSecurityPolicy.id ? newSecurityPolicy.id : policyPasswordHistoryDemo.id
+    });
+    callback == null ? void 0 : callback(policy);
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      policy,
+      saving: false
+    });
+  };
+  mockedActions.loadSecurityPolicyPasswordHistory = async () => {
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setSecurityPolicyPasswordHistoryState({
+      policy: policyPasswordHistoryDemo,
+      loading: false
+    });
+  };
+  mockedActions.loadSecurityPolicyVendorPasswordHistory = async () => {
+    mockedActions.setSecurityPolicyVendorPasswordHistoryState({
+      loading: true,
+      error: null
+    });
+    await delay();
+    mockedActions.setSecurityPolicyVendorPasswordHistoryState({
+      policy: policyPasswordHistoryDemo,
+      loading: false
+    });
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/security/sessionsPolicyActions.mocks.d.ts

@@ -0,0 +1,10 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+import { WithCallback } from '../../../interfaces';
+import { ISessionConfigurations } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setSessionsPolicyState: (state: Partial<import("../../..").SessionsPolicyState>) => void;
+    resetSessionsPolicyState: () => void;
+    loadSessionsPolicy: () => Promise<void>;
+    createOrUpdateSessionsPolicy: (payload: WithCallback<ISessionConfigurations, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/security/sessionsPolicyActions.mocks.js

@@ -0,0 +1,35 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["callback"];
+import { buildSessionsPolicyActions } from '../../../auth/Security/SessionsPolicyState';
+import { mockActionsExpect } from '../../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildSessionsPolicyActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setSessionsPolicyState', 'resetSessionsPolicyState']);
+  mockedActions.loadSessionsPolicy = async () => {
+    mockedActions.setSessionsPolicyState({
+      loading: true,
+      error: null
+    });
+    const sessionPolicyState = store.auth.sessionsPolicyState;
+    mockedActions.setSessionsPolicyState(_extends({}, sessionPolicyState, {
+      loading: false
+    }));
+  };
+  mockedActions.createOrUpdateSessionsPolicy = async payload => {
+    const {
+        callback
+      } = payload,
+      rest = _objectWithoutPropertiesLoose(payload, _excluded);
+    mockedActions.setSessionsPolicyState({
+      loading: true,
+      error: null
+    });
+    callback == null ? void 0 : callback(true);
+    mockedActions.setSessionsPolicyState({
+      configurations: rest,
+      loading: false
+    });
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/sessionsActions.mocks.d.ts

@@ -0,0 +1,13 @@
+import { FronteggState, RestApi, SharedActions, WithId } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setSessionsState: (state: Partial<import("../..").SessionsState>) => void;
+    resetSessionsState: () => void;
+    loadUserSessions: () => Promise<void>;
+    loadCurrentUserSession: () => Promise<void>;
+    deleteUserSession: (payload: WithId<object>) => Promise<void>;
+    deleteAllUserSessions: () => Promise<void>;
+    revokeUserSessions: (payload: import("../../interfaces").WithCallback<{
+        userId: string;
+    }, boolean>) => Promise<void>;
+};
+export default _default;