@beinformed/ui 1.65.29 → 2.0.0-beta.1

package/esm/redux/actions/__tests__/Authorization.spec.js.flow

@@ -1,115 +0,0 @@
-// @flow
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import { handleUnauthorized } from "../Authorization";
-
-import application from "../../../models/application/__mock__/application";
-import { MODULARUI_STATUS } from "../../../constants";
-import { ErrorResponse } from "../../../models";
-import { Cache } from "../../../utils";
-
-const thunkExtra = {
-  subscribe: jest.fn((cb) => {
-    if (typeof cb === "function") {
-      setImmediate(cb);
-    }
-    return jest.fn();
-  }),
-};
-
-const middlewares = [thunk.withExtraArgument(thunkExtra)];
-
-/**
- * We cast the creator to 'any' then to a function that returns 'any'
- * to bypass the strict Dispatch definition in the redux-mock-store flow-typed file.
- */
-const mockStoreCreator: (state: Object) => any =
-  configureMockStore(middlewares);
-
-describe("authorization actions", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    Cache.removeItem("auth");
-  });
-
-  it("handle unauthorized with application present when logged in", async () => {
-    const connectKey = "application(/)(en)";
-    Cache.setItem("auth", true);
-
-    const store = mockStoreCreator({
-      modularui: {
-        [connectKey]: {
-          connectKey: connectKey,
-          model: application,
-          status: MODULARUI_STATUS.FINISHED,
-        },
-      },
-      router: { location: { pathname: "/current-page" } },
-      i18n: { locale: "en" },
-    });
-
-    const errorResponse = new ErrorResponse(
-      { id: "Error.Authentication.InvalidUsername" },
-      connectKey,
-    );
-
-    await store.dispatch(handleUnauthorized(errorResponse));
-
-    const actions = store.getActions();
-
-    expect(actions).toEqual(
-      expect.arrayContaining([
-        { type: "MODULARUI/REMOVE_KEY", payload: connectKey },
-        { type: "START_PROGRESS" },
-        { type: "AUTHENTICATION_LOGOUT" },
-      ]),
-    );
-  });
-
-  it("handle unauthorized when no auth cache and logged out", async () => {
-    const store = mockStoreCreator({
-      modularui: {
-        "/": {
-          connectKey: "/",
-          model: { ...application, isLoggedIn: false },
-          status: MODULARUI_STATUS.FINISHED,
-        },
-      },
-      router: { location: { pathname: "/dashboard" } },
-      i18n: { locale: "en" },
-    });
-
-    const errorResponse = new ErrorResponse(
-      { id: "Error.Authentication.InvalidUsername" },
-      "/",
-    );
-
-    await store.dispatch(handleUnauthorized(errorResponse));
-
-    expect(store.getActions()).toEqual(
-      expect.arrayContaining([{ type: "AUTHENTICATION_LOGOUT" }]),
-    );
-  });
-
-  it("adds current location to 'from' state during redirect", async () => {
-    const currentLocation = { pathname: "/orders", search: "?id=1" };
-    const store = mockStoreCreator({
-      modularui: {},
-      router: { location: currentLocation },
-      i18n: { locale: "en" },
-    });
-
-    // Fix: ErrorResponse expects string or undefined, not null
-    const errorResponse = new ErrorResponse({ id: "ERR" }, undefined);
-
-    await store.dispatch(handleUnauthorized(errorResponse));
-
-    const actions = store.getActions();
-    // Fix: Cast the found action to ReplaceAction to allow .payload access
-    const replaceAction = (actions.find(
-      (a) => typeof a === "object" && a.type === "ROUTER/REPLACE",
-    ): any);
-
-    expect(replaceAction?.payload.state.from).toEqual(currentLocation);
-  });
-});

package/esm/redux/actions/__tests__/CustomErrorResponseHandler.spec.js.flow

@@ -1,72 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import { handleError, setCustomErrorResponseHandler } from "../Error";
-
-const middlewares = [thunk];
-const mockStore = configureMockStore(middlewares);
-
-describe("custom error response handling", () => {
-  it("can set a custom error handler without arguments", () => {
-    const store = mockStore({});
-
-    setCustomErrorResponseHandler(() => {
-      return {
-        type: "CUSTOM_HANDLER",
-      };
-    });
-
-    store.dispatch(handleError());
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: "CUSTOM_HANDLER" }),
-    ]);
-  });
-
-  it("can set a custom error handler reacting to error response", () => {
-    const store = mockStore({});
-
-    setCustomErrorResponseHandler((error) => {
-      // eslint-disable-next-line jest/no-conditional-in-test
-      if (error.isRemoteServiceException) {
-        return {
-          type: "REMOTE_SERVICE_EXCEPTION",
-        };
-      }
-
-      return {
-        type: "CUSTOM_HANDLER",
-      };
-    });
-
-    store.dispatch(handleError({ id: "Error.RemoteServiceException" }));
-
-    expect(store.getActions()).toStrictEqual([
-      { type: "RESET_PROGRESS" },
-      { type: "REMOTE_SERVICE_EXCEPTION" },
-    ]);
-  });
-
-  it("can set a custom error handler reacting to error response and calls the default handler", () => {
-    const store = mockStore({});
-
-    setCustomErrorResponseHandler((error, defaultHandler) => (dispatch) => {
-      // eslint-disable-next-line jest/no-conditional-in-test
-      if (error.isRemoteServiceException) {
-        dispatch({
-          type: "REMOTE_SERVICE_EXCEPTION",
-        });
-      }
-
-      return dispatch(defaultHandler(error));
-    });
-
-    store.dispatch(handleError({ id: "Error.RemoteServiceException" }));
-
-    expect(store.getActions()).toStrictEqual([
-      { type: "RESET_PROGRESS" },
-      expect.objectContaining({ type: "REMOTE_SERVICE_EXCEPTION" }),
-      { type: "NO_ACTION" },
-    ]);
-  });
-});

package/esm/redux/actions/__tests__/Error-server.spec.js.flow

@@ -1,134 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import { handleError } from "../Error";
-
-jest.mock("../../../constants/Constants", () => ({
-  IS_SERVER: true,
-}));
-
-const ROUTER_PUSH = "ROUTER/PUSH";
-
-const middlewares = [thunk];
-const mockStore = configureMockStore(middlewares);
-
-describe("error actions", () => {
-  it("should create a notification action when no error is available", () => {
-    const store = mockStore({});
-
-    store.dispatch(handleError());
-
-    expect(store.getActions()).toStrictEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: "RESET_PROGRESS" }),
-        expect.objectContaining({ type: "SAVE_ERROR" }),
-      ]),
-    );
-  });
-
-  it("dispatches no actions when a reload is executed and a resource no longer exists", () => {
-    const store = mockStore({});
-
-    store.dispatch(
-      handleError({
-        status: 404,
-        isReload: true,
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: "RESET_PROGRESS" }),
-        expect.objectContaining({ type: "NO_ACTION" }),
-      ]),
-    );
-  });
-
-  it("dispatches no actions on remote service exceptions", () => {
-    const store = mockStore({});
-
-    store.dispatch(
-      handleError({
-        id: "Error.RemoteServiceException",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: "RESET_PROGRESS" }),
-        expect.objectContaining({ type: "NO_ACTION" }),
-      ]),
-    );
-  });
-
-  it("has special handling of unauthorized users", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        status: 401,
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: "RESET_PROGRESS" }),
-        expect.objectContaining({ type: "AUTHENTICATION_LOGOUT" }),
-        expect.objectContaining({ type: "ROUTER/REPLACE" }),
-      ]),
-    );
-  });
-
-  it("handles blocked users", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        id: "Error.Authentication.BlockedUser",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: "RESET_PROGRESS" }),
-        expect.objectContaining({ type: ROUTER_PUSH }),
-        expect.objectContaining({ type: "SAVE_ERROR" }),
-      ]),
-    );
-  });
-
-  it("handles concurrent users", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        id: "Error.Authentication.ConcurrentUser",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: "RESET_PROGRESS" }),
-        expect.objectContaining({ type: ROUTER_PUSH }),
-        expect.objectContaining({ type: "SAVE_ERROR" }),
-      ]),
-    );
-  });
-
-  it("handles required password change", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        id: "Error.ChangePasswordRequired",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: "RESET_PROGRESS" }),
-        expect.objectContaining({ type: "CHANGE_PASSWORD" }),
-        expect.objectContaining({ type: ROUTER_PUSH }),
-      ]),
-    );
-  });
-});

package/esm/redux/actions/__tests__/Error.spec.js.flow

@@ -1,116 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import { handleError } from "../Error";
-
-const middlewares = [thunk];
-const mockStore = configureMockStore(middlewares);
-
-const ROUTER_PUSH = "ROUTER/PUSH";
-
-describe("error actions", () => {
-  it("should create a notification action when no error is available", () => {
-    const store = mockStore({});
-
-    store.dispatch(handleError());
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: "SHOW_NOTIFICATION" }),
-    ]);
-  });
-
-  it("dispatches no actions when a reload is executed and a resource no longer exists", () => {
-    const store = mockStore({});
-
-    store.dispatch(
-      handleError({
-        status: 404,
-        isReload: true,
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: "NO_ACTION" }),
-    ]);
-  });
-
-  it("dispatches no actions on remote service exceptions", () => {
-    const store = mockStore({});
-
-    store.dispatch(
-      handleError({
-        id: "Error.RemoteServiceException",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: "NO_ACTION" }),
-    ]);
-  });
-
-  it("has special handling of unauthorized users", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        status: 401,
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: "AUTHENTICATION_LOGOUT" }),
-      expect.objectContaining({ type: "ROUTER/REPLACE" }),
-    ]);
-  });
-
-  it("handles blocked users", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        id: "Error.Authentication.BlockedUser",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: ROUTER_PUSH }),
-      expect.objectContaining({ type: "SHOW_NOTIFICATION" }),
-    ]);
-  });
-
-  it("handles concurrent users", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        id: "Error.Authentication.ConcurrentUser",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: ROUTER_PUSH }),
-      expect.objectContaining({ type: "SHOW_NOTIFICATION" }),
-    ]);
-  });
-
-  it("handles required password change", () => {
-    const store = mockStore({ router: {} });
-
-    store.dispatch(
-      handleError({
-        id: "Error.ChangePasswordRequired",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      expect.objectContaining({ type: "RESET_PROGRESS" }),
-      expect.objectContaining({ type: "CHANGE_PASSWORD" }),
-      expect.objectContaining({ type: ROUTER_PUSH }),
-    ]);
-  });
-});

package/esm/redux/actions/__tests__/Form.spec.js.flow

@@ -1,39 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import { previousObject, cancelForm } from "../Form";
-
-import form from "../../../models/form/__mock__/form";
-
-const middlewares = [thunk];
-const mockStore = configureMockStore(middlewares);
-
-describe("form actions", () => {
-  it("previous object", () => {
-    const store = mockStore({});
-
-    store.dispatch(previousObject(form));
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "MODULARUI/UPDATE_FORM",
-        payload: expect.objectContaining({
-          _contributions: expect.objectContaining({
-            label: "Create person",
-          }),
-        }),
-      },
-    ]);
-  });
-
-  it("cancel form", () => {
-    const store = mockStore({});
-
-    store.dispatch(cancelForm(form));
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "ROUTER/GOBACK",
-      },
-    ]);
-  });
-});

package/esm/redux/actions/__tests__/Modals.spec.js.flow

@@ -1,34 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import { showModal, closeModal } from "../Modals";
-
-const middlewares = [thunk];
-const mockStore = configureMockStore(middlewares);
-
-describe("application actions", () => {
-  it("show modal action", () => {
-    const store = mockStore({});
-
-    store.dispatch(showModal("modal1"));
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SHOW_MODAL",
-        payload: "modal1",
-      },
-    ]);
-  });
-
-  it("hide modal action", () => {
-    const store = mockStore({});
-
-    store.dispatch(closeModal("modal1"));
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "CLOSE_MODAL",
-        payload: "modal1",
-      },
-    ]);
-  });
-});

package/esm/redux/actions/__tests__/Notification.spec.js.flow

@@ -1,94 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-import {
-  dismissNotification,
-  showNotification,
-  showFormNotification,
-  showXHRErrorNotification,
-} from "../Notification";
-
-import { NOTIFICATION_TYPES } from "../../../constants";
-
-import form from "../../../models/form/__mock__/form";
-
-const middlewares = [thunk];
-const mockStore = configureMockStore(middlewares);
-
-describe("notification actions", () => {
-  it("creates a dismiss all notifications action", () => {
-    const store = mockStore({ notification: {} });
-
-    store.dispatch(dismissNotification());
-
-    expect(store.getActions()).toStrictEqual([
-      { type: "DISMISS_NOTIFICATION" },
-    ]);
-  });
-
-  it("create a basic show notification action", () => {
-    const store = mockStore({ showNotification: {} });
-
-    store.dispatch(showNotification(NOTIFICATION_TYPES.SUCCESS, "message"));
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SHOW_NOTIFICATION",
-        payload: { type: "SUCCESS", message: "message", error: undefined },
-      },
-    ]);
-  });
-
-  it("create a show form notification action", () => {
-    const store = mockStore({ showNotification: {} });
-
-    store.dispatch(showFormNotification(form));
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "START_PROGRESS",
-      },
-      {
-        type: "SHOW_NOTIFICATION",
-        payload: {
-          type: "SUCCESS",
-          message: { id: "Notification.Msg.Generic" },
-          error: undefined,
-        },
-      },
-      {
-        type: "FINISH_PROGRESS",
-      },
-    ]);
-  });
-
-  it("create a  show xhr error notification action", () => {
-    const store = mockStore({ showNotification: {} });
-
-    store.dispatch(
-      showXHRErrorNotification({
-        id: "error",
-        message: "message",
-        properties: "properties",
-      }),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SHOW_NOTIFICATION",
-        payload: {
-          type: "ERROR",
-          message: {
-            id: "error",
-            defaultMessage: "message",
-            parameters: "properties",
-          },
-          error: {
-            id: "error",
-            message: "message",
-            properties: "properties",
-          },
-        },
-      },
-    ]);
-  });
-});

package/esm/redux/actions/__tests__/Preferences.spec.js.flow

@@ -1,71 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-
-import {
-  setServerPreference,
-  setPreference,
-  setPreferences,
-  setThemePreference,
-} from "../Preferences";
-
-const middlewares = [thunk];
-const mockStore = configureMockStore(middlewares);
-
-describe("preference actions", () => {
-  it("set server preference, without preferencesProvider", () => {
-    const store = mockStore({ preferences: {} });
-
-    store.dispatch(setServerPreference("name", "default"));
-
-    expect(store.getActions()).toStrictEqual([
-      { type: "SET_PREFERENCE", payload: { name: "default" } },
-    ]);
-  });
-
-  it("set preference", () => {
-    const store = mockStore({ preferences: {} });
-
-    store.dispatch(setPreference("name", "value"));
-
-    expect(store.getActions()).toStrictEqual([
-      { type: "SET_PREFERENCE", payload: { name: "value" } },
-    ]);
-  });
-
-  it("set preferences", () => {
-    const store = mockStore({ preferences: {} });
-
-    store.dispatch(setPreferences({ name: "value" }));
-
-    expect(store.getActions()).toStrictEqual([
-      { type: "SET_PREFERENCES", payload: { name: "value" } },
-    ]);
-  });
-
-  it("theme settings", () => {
-    const store = mockStore({ preferences: {} });
-
-    store.dispatch(
-      setThemePreference(
-        JSON.stringify({
-          settings: {
-            settingName: "settingValue",
-          },
-        }),
-      ),
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          theme: {
-            settings: {
-              settingName: "settingValue",
-            },
-          },
-        },
-      },
-    ]);
-  });
-});