orc-shared 1.7.0-dev.8 → 5.2.0-dev.1

package/src/hooks/useDispatchWithErrorHandling.test.js

@@ -1,230 +0,0 @@
-import React from "react";
-import { useDispatchWithErrorHandling } from "./useDispatchWithErrorHandling";
-import sinon from "sinon";
-import { mount } from "enzyme";
-import { Provider } from "react-redux";
-import Immutable from "immutable";
-import { pushGlobalErrorMessage } from "../actions/globalErrorMessages";
-
-const delay = () => new Promise(resolve => setTimeout(resolve, 10));
-
-describe("useDispatchWithErrorHandling", () => {
-	let store, state, dispatchSpy;
-
-	beforeEach(() => {
-		state = Immutable.fromJS({});
-		dispatchSpy = sinon.stub().named("dispatch");
-
-		store = {
-			subscribe: () => {},
-			dispatch: dispatchSpy,
-			getState: () => state,
-		};
-	});
-
-	it("Dispatches action just with specified parameters", () => {
-		dispatchSpy.resolves({});
-
-		const TestComp = () => {
-			const dispatch = useDispatchWithErrorHandling();
-			dispatch({
-				action: { type: "testing" },
-				errorTitle: "title",
-				errorDescription: "desc",
-				validationLookupModule: "order",
-				validationLookupName: "ValidationsOrderReturns",
-			});
-			return null;
-		};
-
-		const component = (
-			<Provider store={store}>
-				<TestComp />
-			</Provider>
-		);
-
-		mount(component);
-
-		expect(dispatchSpy.callCount, "to be", 1);
-		expect(dispatchSpy, "to have a call satisfying", { args: [{ type: "testing" }] });
-	});
-
-	it("does not push messages because data is null", () => {
-		dispatchSpy.resolves(null);
-
-		const TestComp = () => {
-			const dispatch = useDispatchWithErrorHandling();
-			dispatch({
-				action: { type: "testing" },
-				errorTitle: "title",
-				errorDescription: "desc",
-				validationLookupModule: "order",
-				validationLookupName: "ValidationsOrderReturns",
-			});
-			return null;
-		};
-
-		const component = (
-			<Provider store={store}>
-				<TestComp />
-			</Provider>
-		);
-
-		mount(component);
-
-		expect(dispatchSpy.callCount, "to be", 1);
-	});
-
-	it("does not push messages because data is an empty object", () => {
-		dispatchSpy.resolves({});
-
-		const TestComp = () => {
-			const dispatch = useDispatchWithErrorHandling();
-			dispatch({
-				action: { type: "testing" },
-				errorTitle: "title",
-				errorDescription: "desc",
-				validationLookupModule: "order",
-				validationLookupName: "ValidationsOrderReturns",
-			});
-			return null;
-		};
-
-		const component = (
-			<Provider store={store}>
-				<TestComp />
-			</Provider>
-		);
-
-		mount(component);
-
-		expect(dispatchSpy.callCount, "to be", 1);
-	});
-
-	it("does not push messages because data is a response with error=false", () => {
-		dispatchSpy.resolves({ error: false });
-
-		const TestComp = () => {
-			const dispatch = useDispatchWithErrorHandling();
-			dispatch({
-				action: { type: "testing" },
-				errorTitle: "title",
-				errorDescription: "desc",
-				validationLookupModule: "order",
-				validationLookupName: "ValidationsOrderReturns",
-			});
-			return null;
-		};
-
-		const component = (
-			<Provider store={store}>
-				<TestComp />
-			</Provider>
-		);
-
-		mount(component);
-
-		expect(dispatchSpy.callCount, "to be", 1);
-	});
-
-	it("dispatch new message with title and description because of empty msg list", () => {
-		dispatchSpy.resolves({
-			error: true,
-			payload: {
-				status: 500,
-			},
-		});
-
-		const TestComp = () => {
-			const dispatch = useDispatchWithErrorHandling();
-			dispatch({
-				action: { type: "testing" },
-				errorTitle: "title",
-				errorDescription: "desc",
-				validationLookupModule: "order",
-				validationLookupName: "ValidationsOrderReturns",
-			});
-			return null;
-		};
-
-		const component = (
-			<Provider store={store}>
-				<TestComp />
-			</Provider>
-		);
-
-		mount(component);
-
-		delay().then(() => {
-			expect(dispatchSpy.callCount, "to be", 2);
-			expect(dispatchSpy, "to have a call satisfying", {
-				args: [
-					pushGlobalErrorMessage({
-						title: "title",
-						description: "desc",
-						messages: [],
-					}),
-				],
-			});
-		});
-	});
-
-	it("dispatch new message with only title because msg list is filled", () => {
-		dispatchSpy.resolves({
-			error: true,
-			payload: {
-				status: 500,
-				response: {
-					errors: [
-						{
-							message: "msg",
-							lookupModule: "mod",
-							lookupName: "name",
-							lookupKey: "key",
-						},
-					],
-				},
-			},
-		});
-
-		const TestComp = () => {
-			const dispatch = useDispatchWithErrorHandling();
-			dispatch({
-				action: { type: "testing" },
-				errorTitle: "title",
-				errorDescription: "desc",
-				validationLookupModule: "order",
-				validationLookupName: "ValidationsOrderReturns",
-			});
-			return null;
-		};
-
-		const component = (
-			<Provider store={store}>
-				<TestComp />
-			</Provider>
-		);
-
-		mount(component);
-
-		delay().then(() => {
-			expect(dispatchSpy.callCount, "to be", 2);
-			expect(dispatchSpy, "to have a call satisfying", {
-				args: [
-					pushGlobalErrorMessage({
-						title: "title",
-						description: null,
-						messages: [
-							{
-								message: "msg",
-								lookupModule: "mod",
-								lookupName: "name",
-								lookupKey: "key",
-							},
-						],
-					}),
-				],
-			});
-		});
-	});
-});

package/src/hooks/useScopeGuardLoader.js

@@ -1,25 +0,0 @@
-import { useSelector } from "react-redux";
-import { getScopeChangeInProgress } from "../selectors/scopeRouteState";
-import useLoader from "./useLoader";
-
-// look at scopeRouteState.js for documentation
-
-const useScopeGuardLoader = (actions, cutoutSelector) => {
-	const changeInProgress = useSelector(getScopeChangeInProgress);
-
-	const cutoutSelectorGuard = (...selArgs) => {
-		if (changeInProgress) {
-			return true;
-		}
-
-		if (cutoutSelector) {
-			return cutoutSelector.apply(null, selArgs);
-		}
-
-		return true;
-	};
-
-	useLoader(actions, cutoutSelectorGuard);
-};
-
-export default useScopeGuardLoader;

package/src/hooks/useScopeGuardLoader.test.js

@@ -1,187 +0,0 @@
-import React, { useState } from "react";
-import { mount, act } from "unexpected-reaction";
-import { Provider, useSelector } from "react-redux";
-import Immutable from "immutable";
-import sinon from "sinon";
-import { spyOnConsole } from "../utils/testUtils";
-import useScopeGuardLoader from "./useScopeGuardLoader";
-
-const TestComp = ({ loader, cutout }) => {
-	useScopeGuardLoader(loader, cutout);
-	const [tick, setTick] = useState(0);
-	const live = useSelector(state => state.get("live"));
-	return (
-		<div id="test" onClick={() => setTick(tick + 1)} data-live={live}>
-			{tick}
-		</div>
-	);
-};
-
-describe("useScopeGuardLoader", () => {
-	spyOnConsole(["warn"]);
-
-	let loader, state, store, appNode;
-	beforeEach(() => {
-		state = Immutable.fromJS({
-			cutout: "yes",
-			live: 0,
-			requests: {
-				logout: false,
-			},
-			scopeRouteState: {
-				scopeChangeInProgress: false,
-			},
-		});
-		const subs = [];
-		store = {
-			updateState: () => {
-				subs.forEach((sub, i) => {
-					sub();
-				});
-			},
-			subscribe: sub => {
-				subs.push(sub);
-				return () => {};
-			},
-			getState: () => state,
-			dispatch: sinon.spy().named("dispatch"),
-		};
-		loader = { type: "TEST_ACTION" };
-		appNode = document.createElement("div");
-		document.body.appendChild(appNode);
-	});
-	afterEach(() => {
-		document.body.removeChild(appNode);
-	});
-
-	it("dispatches the loader action on mount if cutout returns falsy", () =>
-		expect(
-			<Provider store={store}>
-				<TestComp loader={loader} cutout={state => state.get("live")} />
-			</Provider>,
-			"when mounted",
-			"to satisfy",
-			<div>0</div>,
-		).then(() => expect(store.dispatch, "to have calls satisfying", [{ args: [loader] }])));
-
-	it("does not dispatch the loader action on mount because scope change is in progress", () => {
-		state = state.setIn(["scopeRouteState", "scopeChangeInProgress"], true);
-
-		return expect(
-			<Provider store={store}>
-				<TestComp loader={loader} cutout={state => state.get("live")} />
-			</Provider>,
-			"when mounted",
-			"to satisfy",
-			<div>0</div>,
-		).then(() => expect(store.dispatch, "not to have calls satisfying", [{ args: [loader] }]));
-	});
-
-	it("does not dispatch loader if cutout returns truthy", () =>
-		expect(
-			<Provider store={store}>
-				<TestComp loader={loader} cutout={state => state.get("cutout")} />
-			</Provider>,
-			"when mounted",
-			"to satisfy",
-			<div>0</div>,
-		).then(() => expect(store.dispatch, "was not called")));
-
-	it("does not dispatch loader if logged out", () => {
-		state = state.setIn(["requests", "logout"], true);
-
-		expect(
-			<Provider store={store}>
-				<TestComp loader={loader} cutout={state => state.get("cutout")} />
-			</Provider>,
-			"when mounted",
-			"to satisfy",
-			<div>0</div>,
-		).then(() => expect(store.dispatch, "was not called"));
-	});
-
-	it("does not dispatch loader if no cutout selector given, warns", () =>
-		expect(
-			<Provider store={store}>
-				<TestComp loader={loader} />
-			</Provider>,
-			"when mounted",
-			"to satisfy",
-			<div>0</div>,
-		)
-			.then(() => expect(store.dispatch, "was not called"))
-			.then(() =>
-				expect(console.warn, "not to have calls satisfying", [
-					{
-						args: ["useLoader hook called without cutout selector, loader will never be dispatched."],
-					},
-				]),
-			));
-
-	it("dispatches multiple loader actions", () => {
-		const loaderSeries = [{ type: "TEST_ACTION1" }, { type: "TEST_ACTION2" }, { type: "TEST_ACTION3" }];
-		return expect(
-			<Provider store={store}>
-				<TestComp loader={loaderSeries} cutout={state => state.get("live")} />
-			</Provider>,
-			"when mounted",
-			"to satisfy",
-			<div>0</div>,
-		).then(() =>
-			expect(store.dispatch, "to have calls satisfying", [
-				{ args: [loaderSeries[0]] },
-				{ args: [loaderSeries[1]] },
-				{ args: [loaderSeries[2]] },
-			]),
-		);
-	});
-
-	it("only dispatches once if cutout does not change", () =>
-		expect(
-			<Provider store={store}>
-				<TestComp loader={loader} cutout={state => state.get("live")} />
-			</Provider>,
-			"when mounted",
-			"with event",
-			"click",
-			"with event",
-			"click",
-			"with event",
-			"click",
-			"with event",
-			"click",
-			"to satisfy",
-			<div>4</div>,
-		).then(() => expect(store.dispatch, "to have calls satisfying", [{ args: [loader] }])));
-
-	it("fires loader if cutout is falsy, but not again if it becomes truthy", () => {
-		const selector = state => state.get("live");
-		mount(
-			<Provider store={store}>
-				<TestComp loader={loader} cutout={selector} />
-			</Provider>,
-		);
-		expect(store.dispatch, "to have calls satisfying", [{}]);
-		act(() => {
-			state = state.set("live", 1);
-			store.updateState();
-		});
-		expect(store.dispatch, "was called once");
-	});
-
-	it("fires loader if cutout was truthy, becomes falsy", () => {
-		const selector = state => state.get("live");
-		state = state.set("live", 1);
-		mount(
-			<Provider store={store}>
-				<TestComp loader={loader} cutout={selector} />
-			</Provider>,
-		);
-		expect(store.dispatch, "was not called");
-		act(() => {
-			state = state.set("live", 0);
-			store.updateState();
-		});
-		expect(store.dispatch, "was called");
-	});
-});

package/src/reducers/globalErrorMessages.js

@@ -1,25 +0,0 @@
-import Immutable from "immutable";
-import { POP_GLOBAL_ERROR_MESSAGE, PUSH_GLOBAL_ERROR_MESSAGE } from "../actions/globalErrorMessages";
-
-const initialState = Immutable.fromJS({
-	dialog: {
-		errorMessages: [],
-	},
-});
-
-const globalErrorMessages = (state = initialState, action) => {
-	switch (action.type) {
-		case PUSH_GLOBAL_ERROR_MESSAGE: {
-			const newMsgs = state.getIn(["dialog", "errorMessages"]).push(Immutable.fromJS(action.payload));
-			return state.setIn(["dialog", "errorMessages"], newMsgs);
-		}
-		case POP_GLOBAL_ERROR_MESSAGE: {
-			const newMsgs = state.getIn(["dialog", "errorMessages"]).shift();
-			return state.setIn(["dialog", "errorMessages"], newMsgs);
-		}
-		default:
-			return state;
-	}
-};
-
-export default globalErrorMessages;

package/src/reducers/globalErrorMessages.test.js

@@ -1,66 +0,0 @@
-import Immutable from "immutable";
-import reducer from "./globalErrorMessages";
-import { popGlobalErrorMessage, pushGlobalErrorMessage } from "../actions/globalErrorMessages";
-
-describe("Global error messages reducer", () => {
-	it("behaves as a reducer should", () =>
-		expect(reducer, "to be a reducer with initial state", {
-			dialog: {
-				errorMessages: [],
-			},
-		}));
-
-	it("save new message to end of the list", () => {
-		const oldState = Immutable.fromJS({
-			dialog: {
-				errorMessages: [{ msg: "123" }],
-			},
-		});
-		const action = pushGlobalErrorMessage({ msg: "456" });
-		const newState = reducer(oldState, action);
-		expect(newState, "not to be", oldState).and(
-			"to equal",
-			Immutable.fromJS({
-				dialog: {
-					errorMessages: [{ msg: "123" }, { msg: "456" }],
-				},
-			}),
-		);
-	});
-
-	it("remove oldest message", () => {
-		const oldState = Immutable.fromJS({
-			dialog: {
-				errorMessages: [{ msg: "123" }, { msg: "456" }],
-			},
-		});
-		const action = popGlobalErrorMessage();
-		const newState = reducer(oldState, action);
-		expect(newState, "not to be", oldState).and(
-			"to equal",
-			Immutable.fromJS({
-				dialog: {
-					errorMessages: [{ msg: "456" }],
-				},
-			}),
-		);
-	});
-
-	it("remove oldest message on an empty list", () => {
-		const oldState = Immutable.fromJS({
-			dialog: {
-				errorMessages: [],
-			},
-		});
-		const action = popGlobalErrorMessage();
-		const newState = reducer(oldState, action);
-		expect(newState, "to be", oldState).and(
-			"to equal",
-			Immutable.fromJS({
-				dialog: {
-					errorMessages: [],
-				},
-			}),
-		);
-	});
-});

package/src/reducers/scopeRouteState.js

@@ -1,29 +0,0 @@
-import Immutable from "immutable";
-import { SET_ROUTE } from "../actions/navigation";
-import { APPLICATION_SCOPE_HAS_CHANGED } from "../actions/scopes";
-
-const initialState = Immutable.fromJS({
-	scopeChangeInProgress: false,
-});
-
-/*
-	This reducer and its associated hook is used to prevent a request from being sent out while the application's scope is changing.
-	Basically the reducer responds to an action, set a flag to true and then set it to false once another action is triggered (route change).
-
-	This is a pretty hackish way to ensure that the correct requests are being executed (references #74924, #74764) however we know of no other way to achieve the desired result.
-* */
-
-const viewStateReducer = (state = initialState, action) => {
-	switch (action.type) {
-		case APPLICATION_SCOPE_HAS_CHANGED: {
-			return state.set("scopeChangeInProgress", action.payload.newScope !== action.payload.previousScope);
-		}
-		case SET_ROUTE: {
-			return state.set("scopeChangeInProgress", false);
-		}
-		default:
-			return state;
-	}
-};
-
-export default viewStateReducer;

package/src/reducers/scopeRouteState.test.js

@@ -1,49 +0,0 @@
-import Immutable from "immutable";
-import { applicationScopeHasChanged } from "../actions/scopes";
-import reducer from "./scopeRouteState";
-import { setRoute } from "../actions/navigation";
-
-describe("scopeRouteState", () => {
-	it("behaves as a reducer should", () =>
-		expect(reducer, "to be a reducer with initial state", { scopeChangeInProgress: false }));
-
-	it("set scopeChangeInProgress to true if scope is different", () => {
-		const oldState = Immutable.Map({
-			scopeChangeInProgress: false,
-		});
-		const action = applicationScopeHasChanged("prevScope", "newScope", "module");
-
-		const newState = reducer(oldState, action);
-		return expect(newState, "not to be", oldState).and(
-			"to satisfy",
-			Immutable.fromJS({
-				scopeChangeInProgress: true,
-			}),
-		);
-	});
-
-	it("scopeChangeInProgress stays false if prev and new scope are identical", () => {
-		const oldState = Immutable.Map({
-			scopeChangeInProgress: false,
-		});
-		const action = applicationScopeHasChanged("sameScope", "sameScope", "module");
-
-		const newState = reducer(oldState, action);
-		return expect(newState, "to be", oldState);
-	});
-
-	it("set scopeChangeInProgress to false when route changes", () => {
-		const oldState = Immutable.Map({
-			scopeChangeInProgress: true,
-		});
-		const action = setRoute("loc", {});
-
-		const newState = reducer(oldState, action);
-		return expect(newState, "not to be", oldState).and(
-			"to satisfy",
-			Immutable.fromJS({
-				scopeChangeInProgress: false,
-			}),
-		);
-	});
-});

package/src/reducers/tasks.js

@@ -1,56 +0,0 @@
-import Immutable from "immutable";
-import { safeGet } from "../utils";
-import {
-	GET_TASK_LIST_SUCCESS,
-	DELETE_TASK_REQUEST,
-	GET_TASK_LOG_SUCCESS,
-	CLEAR_TASK_LOG,
-	GET_TASKINFO_SUCCESS,
-} from "../actions/tasks";
-import { compareObjectProperty } from "../utils/propertyHelper";
-
-const initialState = Immutable.fromJS({
-	tasks: [],
-	taskInfos: {},
-	logs: {},
-});
-
-const tasks = (state = initialState, action) => {
-	switch (action.type) {
-		case GET_TASKINFO_SUCCESS:
-			return state.setIn(["taskInfos", action.payload.taskId], Immutable.fromJS(action.payload));
-		case GET_TASK_LIST_SUCCESS:
-			return state.set(
-				"tasks",
-				Immutable.fromJS(action.payload.sort((a, b) => compareObjectProperty(a, b, "created"))),
-			);
-		case DELETE_TASK_REQUEST:
-			const deleteTaskId = safeGet(action, "meta", "taskId");
-
-			return state.withMutations(s => {
-				s.set(
-					"tasks",
-					s.get("tasks").filter(task => task.get("taskId") !== deleteTaskId),
-				);
-				s.deleteIn(["logs", deleteTaskId]);
-				s.deleteIn(["taskInfos", deleteTaskId]);
-			});
-		case GET_TASK_LOG_SUCCESS:
-			const logTaskId = safeGet(action, "meta", "taskId");
-			if (action.payload?.length > 0) {
-				return state.setIn(
-					["logs", logTaskId],
-					Immutable.fromJS(action.payload.sort((a, b) => compareObjectProperty(a, b, "executionTime"))),
-				);
-			} else {
-				return state.deleteIn(["logs", logTaskId]);
-			}
-		case CLEAR_TASK_LOG:
-			const taskId = safeGet(action, "meta", "taskId");
-			return state.deleteIn(["logs", taskId]);
-		default:
-			return state;
-	}
-};
-
-export default tasks;