orc-shared 1.6.0-dev.4 → 1.6.0-dev.6

package/src/hooks/useDispatchWithErrorHandling.test.js

@@ -0,0 +1,230 @@
+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/reducers/globalErrorMessages.js

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,66 @@
+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/selectors/globalErrorMessages.js

@@ -0,0 +1,11 @@
+import { createSelector } from "reselect";
+
+const globalMsgData = state => state.get("globalErrorMessages");
+
+export const firstDialogErrorMessageSelector = createSelector(globalMsgData, data => {
+	const msgs = data.getIn(["dialog", "errorMessages"]);
+	if (msgs.size === 0) {
+		return null;
+	}
+	return msgs.first().toJS();
+});

package/src/selectors/globalErrorMessages.test.js

@@ -0,0 +1,25 @@
+import Immutable from "immutable";
+import { firstDialogErrorMessageSelector } from "./globalErrorMessages";
+
+describe("firstDialogErrorMessageSelector", () => {
+	let state;
+	beforeEach(() => {
+		state = Immutable.fromJS({
+			globalErrorMessages: {
+				dialog: {
+					errorMessages: [{ msg: "123" }, { msg: "456" }],
+				},
+			},
+			view: {},
+		});
+	});
+
+	it("gets the first message", () => {
+		expect(firstDialogErrorMessageSelector, "called with", [state], "to satisfy", { msg: "123" });
+	});
+
+	it("gets the first message on an empty list", () => {
+		state = state.setIn(["globalErrorMessages", "dialog", "errorMessages"], Immutable.fromJS([]));
+		expect(firstDialogErrorMessageSelector, "called with", [state], "to satisfy", null);
+	});
+});

package/src/utils/responseProcessingHelper.js

@@ -0,0 +1,41 @@
+export const extractStandardErrorMessagesFromResponse = (response, validationLookupModule, validationLookupName) => {
+	let hasErrors = false;
+	const messages = [];
+
+	if (response?.error) {
+		hasErrors = true;
+
+		if (response.payload?.status === 422) {
+			if (response.payload?.response?.failures) {
+				// uses structure from our .Net ValidationFailuresExceptionHandler
+				response.payload.response.failures.forEach(failure => {
+					if (failure.errorCode) {
+						messages.push({
+							message: failure.errorMessage,
+							lookupModule: validationLookupModule,
+							lookupName: validationLookupName,
+							lookupKey: failure.errorCode,
+						});
+					}
+				});
+			}
+		} else if (response.payload?.status === 500) {
+			if (response.payload?.response?.errors) {
+				// uses structure from our .Net OrckestraExceptionErrorHandler
+				response.payload.response.errors.forEach(err => {
+					messages.push({
+						message: err.message,
+						lookupModule: err.lookupModule,
+						lookupName: err.lookupName,
+						lookupKey: err.lookupKey,
+					});
+				});
+			}
+		}
+	}
+
+	return {
+		hasErrors,
+		messages,
+	};
+};

package/src/utils/responseProcessingHelper.test.js

@@ -0,0 +1,182 @@
+import { extractStandardErrorMessagesFromResponse } from "./responseProcessingHelper";
+
+describe("extractStandardErrorMessagesFromResponse", () => {
+	it("Returns success when response is null", () => {
+		const response = null;
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+		expect(extractedMessages, "to equal", {
+			hasErrors: false,
+			messages: [],
+		});
+	});
+
+	it("Returns success when response is empty", () => {
+		const response = {};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: false,
+			messages: [],
+		});
+	});
+
+	it("Returns success when response is not on error", () => {
+		const response = {
+			error: false,
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: false,
+			messages: [],
+		});
+	});
+
+	it("Returns error with empty messages with 422 error", () => {
+		const response = {
+			error: true,
+			payload: {
+				status: 422,
+			},
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [],
+		});
+	});
+
+	it("Returns error with empty messages with 422 error because empty failures", () => {
+		const response = {
+			error: true,
+			payload: {
+				status: 422,
+				failures: [],
+			},
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [],
+		});
+	});
+
+	it("Returns error with empty messages with 422 errors", () => {
+		const response = {
+			error: true,
+			payload: {
+				status: 422,
+				response: {
+					failures: [
+						{ invalid: "format" },
+						{ errorCode: "code1", errorMessage: "msg1" },
+						{ errorCode: "code2", errorMessage: "msg2" },
+					],
+				},
+			},
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [
+				{ message: "msg1", lookupModule: "fallback module", lookupName: "fallback name", lookupKey: "code1" },
+				{ message: "msg2", lookupModule: "fallback module", lookupName: "fallback name", lookupKey: "code2" },
+			],
+		});
+	});
+
+	it("Returns error with empty messages with 422 errors", () => {
+		const response = {
+			error: true,
+			payload: {
+				status: 422,
+				response: {
+					failures: [
+						{ invalid: "format" },
+						{ errorCode: "code1", errorMessage: "msg1" },
+						{ errorCode: "code2", errorMessage: "msg2" },
+					],
+				},
+			},
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [
+				{ message: "msg1", lookupModule: "fallback module", lookupName: "fallback name", lookupKey: "code1" },
+				{ message: "msg2", lookupModule: "fallback module", lookupName: "fallback name", lookupKey: "code2" },
+			],
+		});
+	});
+
+	it("Returns error with empty messages with 500 status but no messages", () => {
+		const response = {
+			error: true,
+			payload: {
+				status: 500,
+			},
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [],
+		});
+	});
+
+	it("Returns error with empty messages with 500 status without payload", () => {
+		const response = {
+			error: true,
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [],
+		});
+	});
+
+	it("Returns error with empty messages with 500 with empty messages", () => {
+		const response = {
+			error: true,
+			payload: {
+				status: 500,
+				errors: [],
+			},
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [],
+		});
+	});
+
+	it("Returns error with empty messages with 500 with messages", () => {
+		const response = {
+			error: true,
+			payload: {
+				status: 500,
+				response: {
+					errors: [
+						{ message: "msg1", lookupModule: "mod2", lookupName: "name3", lookupKey: "key4" },
+						{ message: "", lookupModule: "mod5", lookupName: "name5", lookupKey: "key5" },
+					],
+				},
+			},
+		};
+		const extractedMessages = extractStandardErrorMessagesFromResponse(response, "fallback module", "fallback name");
+
+		expect(extractedMessages, "to equal", {
+			hasErrors: true,
+			messages: [
+				{ message: "msg1", lookupModule: "mod2", lookupName: "name3", lookupKey: "key4" },
+				{ message: "", lookupModule: "mod5", lookupName: "name5", lookupKey: "key5" },
+			],
+		});
+	});
+});