@frontegg/redux-store 5.61.0 → 6.0.1-alpha.2

package/auth/SecurityPolicyState/index.js

@@ -0,0 +1,64 @@
+import { createAction } from '@reduxjs/toolkit';
+import { resetStateByKey, typeReducerForKey, typeReducerNestedKey } from '../utils';
+import { authStoreName } from '../../constants';
+const securityPolicyState = {
+  globalPolicy: {
+    loading: true
+  },
+  publicPolicy: {
+    loading: false
+  },
+  vendorMfaPolicy: {
+    loading: true
+  },
+  mfaPolicy: {
+    loading: true
+  },
+  lockoutPolicy: {
+    loading: true
+  },
+  captchaPolicy: {
+    loading: true
+  },
+  passwordHistoryPolicy: {
+    loading: true
+  },
+  passwordPolicy: {
+    loading: true
+  }
+};
+const reducers = {
+  setSecurityPolicyState: typeReducerForKey('securityPolicyState'),
+  setSecurityPolicyGlobalState: typeReducerNestedKey('securityPolicyState', 'globalPolicy'),
+  setSecurityPolicyPublicState: typeReducerNestedKey('securityPolicyState', 'publicPolicy'),
+  setSecurityPolicyMfaState: typeReducerNestedKey('securityPolicyState', 'mfaPolicy'),
+  setSecurityPolicyVendorMfaState: typeReducerNestedKey('securityPolicyState', 'vendorMfaPolicy'),
+  setSecurityPolicyLockoutState: typeReducerNestedKey('securityPolicyState', 'lockoutPolicy'),
+  setSecurityPolicyCaptchaState: typeReducerNestedKey('securityPolicyState', 'captchaPolicy'),
+  setSecurityPolicyPasswordHistoryState: typeReducerNestedKey('securityPolicyState', 'passwordHistoryPolicy'),
+  setSecurityPolicyPasswordState: typeReducerNestedKey('securityPolicyState', 'passwordPolicy'),
+  resetSecurityPolicyState: resetStateByKey('securityPolicyState', {
+    securityPolicyState
+  })
+};
+const actions = {
+  loadSecurityPolicy: createAction(`${authStoreName}/loadSecurityPolicy`),
+  loadPublicSecurityPolicy: createAction(`${authStoreName}/loadPublicSecurityPolicy`),
+  loadSecurityPolicyMfa: createAction(`${authStoreName}/loadSecurityPolicyMfa`),
+  loadSecurityPolicyVendorMfa: createAction(`${authStoreName}/loadSecurityPolicyVendorMfa`),
+  saveSecurityPolicyMfa: createAction(`${authStoreName}/saveSecurityPolicyMfa`, payload => ({
+    payload
+  })),
+  loadSecurityPolicyLockout: createAction(`${authStoreName}/loadSecurityPolicyLockout`),
+  saveSecurityPolicyLockout: createAction(`${authStoreName}/saveSecurityPolicyLockout`, payload => ({
+    payload
+  })),
+  loadSecurityPolicyCaptcha: createAction(`${authStoreName}/loadSecurityPolicyCaptcha`),
+  loadSecurityPolicyPasswordHistory: createAction(`${authStoreName}/loadSecurityPolicyPasswordHistory`),
+  saveSecurityPolicyPasswordHistory: createAction(`${authStoreName}/saveSecurityPolicyPasswordHistory`, payload => ({
+    payload
+  })),
+  loadVendorPasswordConfig: createAction(`${authStoreName}/loadVendorPasswordConfig`)
+};
+const Matcher = {};
+export { securityPolicyState, reducers as securityPolicyReducers, actions as securityPolicyActions };

package/auth/SecurityPolicyState/interfaces.d.ts

@@ -1,28 +1,26 @@
-import { WithCallback, WithStatus } from '../../interfaces';
-import { ISaveSecurityPolicyLockout, ISaveSecurityPolicyMfa, ISaveSecurityPolicyPasswordHistory, ISecurityPolicy, ISecurityPolicyCaptcha, ISecurityPolicyLockout, ISecurityPolicyMfa, ISecurityPolicyPasswordHistory, ISecurityPolicyPasswordConfig, IVendorConfig, IAuthStrategiesConfig } from '@frontegg/rest-api';
-declare type PolicyState<T> = WithStatus & {
-    policy?: T;
-};
-export declare type GlobalPolicyState = PolicyState<ISecurityPolicy>;
-export declare type PublicPolicyState = PolicyState<IVendorConfig>;
-export declare type MfaPolicyState = PolicyState<ISecurityPolicyMfa>;
-export declare type LockoutPolicyState = PolicyState<ISecurityPolicyLockout>;
-export declare type CaptchaPolicyState = PolicyState<ISecurityPolicyCaptcha>;
-export declare type PasswordHistoryPolicyState = PolicyState<ISecurityPolicyPasswordHistory>;
-export declare type PasswordPolicyState = PolicyState<ISecurityPolicyPasswordConfig>;
-export declare type PublicAuthStrategyPolicyState = PolicyState<IAuthStrategiesConfig>;
-export interface SecurityPolicyState {
-    globalPolicy: GlobalPolicyState;
-    publicPolicy: PublicPolicyState;
-    mfaPolicy: MfaPolicyState;
-    vendorMfaPolicy: MfaPolicyState;
-    lockoutPolicy: LockoutPolicyState;
-    captchaPolicy: CaptchaPolicyState;
-    passwordHistoryPolicy: PasswordHistoryPolicyState;
-    passwordPolicy: PasswordPolicyState;
-    publicAuthStrategyPolicy: PublicAuthStrategyPolicyState;
-}
-export declare type SaveSecurityPolicyMfaPayload = WithCallback<ISaveSecurityPolicyMfa, ISecurityPolicyMfa>;
-export declare type SaveSecurityPolicyLockoutPayload = WithCallback<ISaveSecurityPolicyLockout, ISecurityPolicyLockout>;
-export declare type SaveSecurityPolicyPasswordHistoryPayload = WithCallback<ISaveSecurityPolicyPasswordHistory, ISecurityPolicyPasswordHistory>;
-export {};
+import { WithCallback, WithStatus } from '../../interfaces';
+import { ISaveSecurityPolicyLockout, ISaveSecurityPolicyMfa, ISaveSecurityPolicyPasswordHistory, ISecurityPolicy, ISecurityPolicyCaptcha, ISecurityPolicyLockout, ISecurityPolicyMfa, ISecurityPolicyPasswordHistory, ISecurityPolicyPasswordConfig, IVendorConfig } from '@frontegg/rest-api';
+declare type PolicyState<T> = WithStatus & {
+    policy?: T;
+};
+export declare type GlobalPolicyState = PolicyState<ISecurityPolicy>;
+export declare type PublicPolicyState = PolicyState<IVendorConfig>;
+export declare type MfaPolicyState = PolicyState<ISecurityPolicyMfa>;
+export declare type LockoutPolicyState = PolicyState<ISecurityPolicyLockout>;
+export declare type CaptchaPolicyState = PolicyState<ISecurityPolicyCaptcha>;
+export declare type PasswordHistoryPolicyState = PolicyState<ISecurityPolicyPasswordHistory>;
+export declare type PasswordPolicyState = PolicyState<ISecurityPolicyPasswordConfig>;
+export interface SecurityPolicyState {
+    globalPolicy: GlobalPolicyState;
+    publicPolicy: PublicPolicyState;
+    mfaPolicy: MfaPolicyState;
+    vendorMfaPolicy: MfaPolicyState;
+    lockoutPolicy: LockoutPolicyState;
+    captchaPolicy: CaptchaPolicyState;
+    passwordHistoryPolicy: PasswordHistoryPolicyState;
+    passwordPolicy: PasswordPolicyState;
+}
+export declare type SaveSecurityPolicyMfaPayload = WithCallback<ISaveSecurityPolicyMfa, ISecurityPolicyMfa>;
+export declare type SaveSecurityPolicyLockoutPayload = WithCallback<ISaveSecurityPolicyLockout, ISecurityPolicyLockout>;
+export declare type SaveSecurityPolicyPasswordHistoryPayload = WithCallback<ISaveSecurityPolicyPasswordHistory, ISecurityPolicyPasswordHistory>;
+export {};

package/auth/SecurityPolicyState/interfaces.js

@@ -0,0 +1 @@
+export {};

package/auth/SecurityPolicyState/saga.d.ts

@@ -1,24 +1,18 @@
-import { IVendorConfig } from '@frontegg/rest-api';
-export declare function loadPublicSecurityPolicy(): Generator<import("redux-saga/effects").PutEffect<{
-    payload: Partial<import("../../interfaces").WithStatus & {
-        policy?: IVendorConfig | undefined;
-    }>;
-    type: string;
-}> | import("redux-saga/effects").CallEffect<IVendorConfig>, void, IVendorConfig>;
-export declare function loadPublicAuthStrategiesPolicy(): Generator<import("redux-saga/effects").PutEffect<{
-    payload: Partial<import("../../interfaces").WithStatus & {
-        policy?: import("@frontegg/rest-api").IAuthStrategiesConfig | undefined;
-    }>;
-    type: string;
-}> | import("redux-saga/effects").CallEffect<import("@frontegg/rest-api").IAuthStrategiesConfig>, void, unknown>;
-export declare function securityPolicySagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
-/*********************************
- *  Preview Sagas
- *********************************/
-export declare function loadPublicSecurityPolicyMock(): Generator<import("redux-saga/effects").PutEffect<{
-    payload: Partial<import("../../interfaces").WithStatus & {
-        policy?: IVendorConfig | undefined;
-    }>;
-    type: string;
-}>, void, unknown>;
-export declare function securityPolicySagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+import { IVendorConfig } from '@frontegg/rest-api';
+export declare function loadPublicSecurityPolicy(): Generator<import("redux-saga/effects").CallEffect<IVendorConfig> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../../interfaces").WithStatus & {
+        policy?: IVendorConfig | undefined;
+    }>;
+    type: string;
+}>, void, IVendorConfig>;
+export declare function securityPolicySagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+/*********************************
+ *  Preview Sagas
+ *********************************/
+export declare function loadPublicSecurityPolicyMock(): Generator<import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../../interfaces").WithStatus & {
+        policy?: IVendorConfig | undefined;
+    }>;
+    type: string;
+}>, void, unknown>;
+export declare function securityPolicySagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;

package/auth/SecurityPolicyState/saga.js

@@ -0,0 +1,464 @@
+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"],
+      _excluded5 = ["callback"],
+      _excluded6 = ["callback"];
+import { call, put, takeEvery, takeLeading } from 'redux-saga/effects';
+import { api } from '@frontegg/rest-api';
+import { actions } from '../reducer';
+import { delay } from '../utils';
+import { policyDemo, policyMfaDemo, policyLockoutDemo, policyPasswordHistoryDemo, publicSecurityPolicy } from '../dummy';
+
+function* loadSecurityPolicy() {
+  yield put(actions.setSecurityPolicyGlobalState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getGlobalSecurityPolicy);
+    yield put(actions.setSecurityPolicyGlobalState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyGlobalState({
+      error: e.message,
+      loading: false
+    }));
+  }
+
+  yield put(actions.loadSecurityPolicyMfa());
+  yield put(actions.loadSecurityPolicyVendorMfa());
+  yield put(actions.loadSecurityPolicyLockout());
+  yield put(actions.loadSecurityPolicyCaptcha());
+}
+
+export function* loadPublicSecurityPolicy() {
+  yield put(actions.setSecurityPolicyPublicState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getVendorConfig);
+    yield put(actions.setSecurityPolicyPublicState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyPublicState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+function* loadSecurityPolicyMfa() {
+  yield put(actions.setSecurityPolicyMfaState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getMfaPolicy);
+    yield put(actions.setSecurityPolicyMfaState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyMfaState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+function* loadSecurityPolicyVendorMfa() {
+  yield put(actions.setSecurityPolicyMfaState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getVendorMfaPolicy);
+    yield put(actions.setSecurityPolicyVendorMfaState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyVendorMfaState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+function* saveSecurityPolicyMfa(_ref) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(_ref.payload, _excluded);
+
+  yield put(actions.setSecurityPolicyMfaState({
+    saving: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.saveMfaPolicy, newSecurityPolicy);
+    yield put(actions.setSecurityPolicyMfaState({
+      policy,
+      saving: false
+    }));
+    callback == null ? void 0 : callback(policy);
+  } catch (e) {
+    yield put(actions.setSecurityPolicyMfaState({
+      saving: false,
+      error: e.message
+    }));
+    callback == null ? void 0 : callback(null, e);
+  }
+}
+
+function* loadSecurityPolicyLockout() {
+  yield put(actions.setSecurityPolicyLockoutState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getLockoutPolicy);
+    yield put(actions.setSecurityPolicyLockoutState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyLockoutState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+function* saveSecurityPolicyLockout(_ref2) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref2,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(_ref2.payload, _excluded2);
+
+  yield put(actions.setSecurityPolicyLockoutState({
+    saving: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.saveLockoutPolicy, newSecurityPolicy);
+    yield put(actions.setSecurityPolicyLockoutState({
+      policy,
+      saving: false
+    }));
+    callback == null ? void 0 : callback(policy);
+  } catch (e) {
+    yield put(actions.setSecurityPolicyLockoutState({
+      saving: false,
+      error: e.message
+    }));
+    callback == null ? void 0 : callback(null, e);
+  }
+}
+
+function* loadSecurityPolicyCaptcha() {
+  yield put(actions.setSecurityPolicyLockoutState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getCaptchaPolicy);
+    yield put(actions.setSecurityPolicyCaptchaState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyCaptchaState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+function* loadSecurityPolicyPasswordHistory() {
+  yield put(actions.setSecurityPolicyPasswordHistoryState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getPasswordHistoryPolicy);
+    yield put(actions.setSecurityPolicyPasswordHistoryState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyPasswordHistoryState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+function* saveSecurityPolicyPasswordHistory(_ref3) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref3,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(_ref3.payload, _excluded3);
+
+  yield put(actions.setSecurityPolicyPasswordHistoryState({
+    saving: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.savePasswordHistoryPolicy, newSecurityPolicy);
+    yield put(actions.setSecurityPolicyPasswordHistoryState({
+      policy,
+      saving: false
+    }));
+    callback == null ? void 0 : callback(policy);
+  } catch (e) {
+    yield put(actions.setSecurityPolicyPasswordHistoryState({
+      saving: false,
+      error: e.message
+    }));
+    callback == null ? void 0 : callback(null, e);
+  }
+}
+
+function* loadVendorPasswordConfig() {
+  yield put(actions.setSecurityPolicyPasswordState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    const policy = yield call(api.auth.getPasswordConfigPolicy);
+    yield put(actions.setSecurityPolicyPasswordState({
+      policy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyPasswordState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+export function* securityPolicySagas() {
+  yield takeLeading(actions.loadSecurityPolicy, loadSecurityPolicy);
+  yield takeEvery(actions.saveSecurityPolicyMfa, saveSecurityPolicyMfa);
+  yield takeEvery(actions.loadSecurityPolicyMfa, loadSecurityPolicyMfa);
+  yield takeEvery(actions.loadSecurityPolicyVendorMfa, loadSecurityPolicyVendorMfa);
+  yield takeEvery(actions.saveSecurityPolicyLockout, saveSecurityPolicyLockout);
+  yield takeEvery(actions.loadSecurityPolicyLockout, loadSecurityPolicyLockout);
+  yield takeEvery(actions.loadSecurityPolicyCaptcha, loadSecurityPolicyCaptcha);
+  yield takeEvery(actions.saveSecurityPolicyPasswordHistory, saveSecurityPolicyPasswordHistory);
+  yield takeEvery(actions.loadSecurityPolicyPasswordHistory, loadSecurityPolicyPasswordHistory);
+  yield takeEvery(actions.loadVendorPasswordConfig, loadVendorPasswordConfig);
+  yield takeEvery(actions.loadPublicSecurityPolicy, loadPublicSecurityPolicy);
+}
+export function* loadPublicSecurityPolicyMock() {
+  yield put(actions.setSecurityPolicyPublicState({
+    loading: true,
+    error: null
+  }));
+
+  try {
+    yield put(actions.setSecurityPolicyPublicState({
+      policy: publicSecurityPolicy,
+      loading: false
+    }));
+  } catch (e) {
+    yield put(actions.setSecurityPolicyPublicState({
+      error: e.message,
+      loading: false
+    }));
+  }
+}
+
+function* loadSecurityPolicyMock() {
+  yield put(actions.setSecurityPolicyGlobalState({
+    loading: true,
+    error: null
+  }));
+  yield delay();
+  yield put(actions.setSecurityPolicyGlobalState({
+    policy: policyDemo,
+    loading: false
+  }));
+  yield put(actions.loadSecurityPolicyMfa());
+  yield put(actions.loadSecurityPolicyVendorMfa());
+  yield put(actions.loadSecurityPolicyLockout());
+  yield put(actions.loadSecurityPolicyCaptcha());
+}
+
+function* loadSecurityPolicyMfaMock() {
+  yield put(actions.setSecurityPolicyMfaState({
+    loading: true,
+    error: null
+  }));
+  yield delay();
+  yield put(actions.setSecurityPolicyMfaState({
+    policy: policyMfaDemo,
+    loading: false
+  }));
+}
+
+function* loadSecurityPolicyVendorMfaMock() {
+  yield put(actions.setSecurityPolicyVendorMfaState({
+    loading: true,
+    error: null
+  }));
+  yield delay();
+  yield put(actions.setSecurityPolicyVendorMfaState({
+    policy: policyMfaDemo,
+    loading: false
+  }));
+}
+
+function* saveSecurityPolicyMfaMock(_ref4) {
+  var _newSecurityPolicy$id;
+
+  let {
+    payload: {
+      callback
+    }
+  } = _ref4,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(_ref4.payload, _excluded4);
+
+  yield put(actions.setSecurityPolicyMfaState({
+    saving: true,
+    error: null
+  }));
+
+  const policy = _extends({}, policyLockoutDemo, {
+    id: (_newSecurityPolicy$id = newSecurityPolicy.id) != null ? _newSecurityPolicy$id : policyLockoutDemo.id,
+    enforceMFAType: newSecurityPolicy.enforceMFAType
+  });
+
+  yield delay();
+  yield put(actions.setSecurityPolicyMfaState({
+    policy,
+    saving: false
+  }));
+  callback == null ? void 0 : callback(policy);
+}
+
+function* loadSecurityPolicyLockoutMock() {
+  yield put(actions.setSecurityPolicyLockoutState({
+    loading: true,
+    error: null
+  }));
+  yield delay();
+  yield put(actions.setSecurityPolicyLockoutState({
+    policy: policyLockoutDemo,
+    loading: false
+  }));
+}
+
+function* saveSecurityPolicyLockoutMock(_ref5) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref5,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(_ref5.payload, _excluded5);
+
+  yield put(actions.setSecurityPolicyLockoutState({
+    saving: true,
+    error: null
+  }));
+  yield delay();
+
+  const policy = _extends({}, newSecurityPolicy, policyLockoutDemo, {
+    id: newSecurityPolicy.id ? newSecurityPolicy.id : policyLockoutDemo.id
+  });
+
+  callback == null ? void 0 : callback(policy);
+  yield put(actions.setSecurityPolicyLockoutState({
+    policy,
+    saving: false
+  }));
+}
+
+function* loadSecurityPolicyCaptchaMock() {
+  yield put(actions.setSecurityPolicyLockoutState({
+    loading: true,
+    error: null
+  }));
+  yield delay();
+  yield put(actions.setSecurityPolicyLockoutState({
+    policy: policyLockoutDemo,
+    loading: false
+  }));
+}
+
+function* loadSecurityPolicyPasswordHistoryMock() {
+  yield put(actions.setSecurityPolicyPasswordHistoryState({
+    loading: true,
+    error: null
+  }));
+  yield delay();
+  yield put(actions.setSecurityPolicyPasswordHistoryState({
+    policy: policyPasswordHistoryDemo,
+    loading: false
+  }));
+}
+
+function* saveSecurityPolicyPasswordHistoryMock(_ref6) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref6,
+      newSecurityPolicy = _objectWithoutPropertiesLoose(_ref6.payload, _excluded6);
+
+  yield put(actions.setSecurityPolicyPasswordHistoryState({
+    saving: true,
+    error: null
+  }));
+  yield delay();
+
+  const policy = _extends({}, newSecurityPolicy, policyPasswordHistoryDemo, {
+    id: newSecurityPolicy.id ? newSecurityPolicy.id : policyPasswordHistoryDemo.id
+  });
+
+  callback == null ? void 0 : callback(policy);
+  yield put(actions.setSecurityPolicyPasswordHistoryState({
+    policy,
+    saving: false
+  }));
+}
+
+export function* securityPolicySagasMock() {
+  yield takeLeading(actions.loadSecurityPolicy, loadSecurityPolicyMock);
+  yield takeEvery(actions.loadPublicSecurityPolicy, loadPublicSecurityPolicyMock);
+  yield takeEvery(actions.saveSecurityPolicyMfa, saveSecurityPolicyMfaMock);
+  yield takeEvery(actions.loadSecurityPolicyMfa, loadSecurityPolicyMfaMock);
+  yield takeEvery(actions.loadSecurityPolicyVendorMfa, loadSecurityPolicyVendorMfaMock);
+  yield takeEvery(actions.saveSecurityPolicyLockout, saveSecurityPolicyLockoutMock);
+  yield takeEvery(actions.loadSecurityPolicyLockout, loadSecurityPolicyLockoutMock);
+  yield takeEvery(actions.loadSecurityPolicyCaptcha, loadSecurityPolicyCaptchaMock);
+  yield takeEvery(actions.saveSecurityPolicyPasswordHistory, saveSecurityPolicyPasswordHistoryMock);
+  yield takeEvery(actions.loadSecurityPolicyPasswordHistory, loadSecurityPolicyPasswordHistoryMock);
+}