orc-shared 1.2.0-dev.1 → 1.2.0-dev.5

package/src/components/Modules.test.js

@@ -7,17 +7,21 @@ import TabBar from "./MaterialUI/Navigation/TabBar";
 import { TestWrapper, createMuiTheme } from "./../utils/testUtils";
 import sinon from "sinon";
 import { createMemoryHistory } from "history";
+import { INITIALIZE_FIRST_MODULE_SCOPE, SET_MODULE_AS_VISIBLE, SET_ROUTING_PERFORMED } from "../actions/modules";
+import { resetLastScope } from "../selectors/navigation";
 
 describe("Modules", () => {
-	let modules, Mod2, Mod3, Page1, Page2, Page3, store, state;
-
-	const match = {
-		url: "/TestScope/users/page1",
-		path: "/:scope/users/page1",
-		params: { scope: "TestScope" },
-	};
+	let modules, Mod2, Mod3, Page1, Page2, Page3, store, state, match;
 
 	beforeEach(() => {
+		resetLastScope();
+
+		match = {
+			url: "/TestScope/users/page1",
+			path: "/:scope/users/page1",
+			params: { scope: "TestScope" },
+		};
+
 		Mod2 = () => <div id="Mod2" />;
 		Mod3 = () => <div id="Mod3" />;
 		Page1 = () => <div id="Page1" />;
@@ -68,9 +72,6 @@ describe("Modules", () => {
 			router: {
 				location: {},
 			},
-			modules: {
-				tree: {},
-			},
 			view: {
 				edit: {
 					users: {},
@@ -83,6 +84,7 @@ describe("Modules", () => {
 			},
 			settings: {
 				defaultScope: "myScope",
+				modules: ["users", "demos", "photos"],
 			},
 			scopes: {
 				TestScope: {
@@ -93,6 +95,23 @@ describe("Modules", () => {
 					children: ["test2"],
 					isAuthorizedScope: true,
 				},
+				TestScope1: {
+					id: "TestScope1",
+					name: { "en-CA": "Test 1" },
+					foo: false,
+					bar: false,
+					children: ["test2"],
+					isAuthorizedScope: false,
+				},
+			},
+			modules: {
+				tree: {},
+				visibleModules: ["users", "demos", "photos"],
+				lastScopeAndModuleSelection: {
+					scope: "TestScope",
+					moduleName: null,
+					routingPerformed: false,
+				},
 			},
 			locale: {
 				locale: null,
@@ -104,7 +123,7 @@ describe("Modules", () => {
 		});
 		store = {
 			subscribe: () => {},
-			dispatch: () => {},
+			dispatch: sinon.spy().named("dispatch"),
 			getState: () => state,
 		};
 	});
@@ -148,6 +167,144 @@ describe("Modules", () => {
 		expect(mount(component).childNodes, "to satisfy", expected);
 	});
 
+	it("renders a module table when routing is required for photos", () => {
+		const history = createMemoryHistory({ initialEntries: ["/TestScope/demos?arg=data"] });
+		const mockHistoryPush = sinon.spy(history, "push");
+
+		const component = (
+			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
+				<Modules modules={modules} scope="TestScope" />
+			</TestWrapper>
+		);
+
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "moduleName"], "photos");
+
+		const module = {
+			icon: "image",
+			label: "Module 2",
+			href: "/TestScope/photos",
+			mappedFrom: "/TestScope/photos",
+			active: true,
+		};
+
+		const expected = [
+			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
+				<TabBar module={module} pages={[]} />
+			</TestWrapper>,
+			<Mod2 />,
+		];
+
+		expect(mount(component).childNodes, "to satisfy", expected);
+
+		expect(mockHistoryPush, "to have calls satisfying", [{ args: ["/TestScope/photos"] }]);
+
+		expect(store.dispatch, "to have a call satisfying", { args: [{ type: SET_ROUTING_PERFORMED }] });
+	});
+
+	it("renders a module table when routing is required for photos when already set correctly", () => {
+		match.url = "/TestScope/demos";
+		match.path = "/:scope/demos";
+
+		const component = (
+			<TestWrapper
+				provider={{ store }}
+				memoryRouter={{ initialEntries: ["/TestScope/demos"] }}
+				intlProvider
+				stylesProvider
+				muiThemeProvider={{ theme }}
+			>
+				<Modules modules={modules} scope="TestScope" />
+			</TestWrapper>
+		);
+
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "routingPerformed"], true);
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "moduleName"], "demos");
+
+		const module = {
+			icon: "cloud",
+			label: "Module 3",
+			href: "/TestScope/demos",
+			mappedFrom: "/TestScope/demos",
+			active: true,
+		};
+
+		const expected = [
+			<TestWrapper
+				provider={{ store }}
+				memoryRouter={{ initialEntries: ["/TestScope/demos"] }}
+				intlProvider
+				stylesProvider
+				muiThemeProvider={{ theme }}
+			>
+				<TabBar module={module} pages={[]} />
+			</TestWrapper>,
+			<Mod3 />,
+		];
+
+		expect(mount(component).childNodes, "to satisfy", expected);
+	});
+
+	it("renders a module table on first available module if requested one not visible", () => {
+		const history = createMemoryHistory({ initialEntries: ["/TestScope/demos?arg=data"] });
+		const mockHistoryPush = sinon.spy(history, "push");
+
+		const component = (
+			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
+				<Modules modules={modules} scope="TestScope" />
+			</TestWrapper>
+		);
+
+		state = state.setIn(["modules", "visibleModules"], Immutable.fromJS(["demos", "users"]));
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "moduleName"], "photos");
+
+		const module = {
+			icon: "cloud",
+			label: "Module 3",
+			href: "/TestScope/demos",
+			mappedFrom: "/TestScope/demos",
+			active: true,
+		};
+
+		const expected = [
+			<TestWrapper
+				provider={{ store }}
+				memoryRouter={{ initialEntries: ["/TestScope/demos"] }}
+				intlProvider
+				stylesProvider
+				muiThemeProvider={{ theme }}
+			>
+				<TabBar module={module} pages={[]} />
+			</TestWrapper>,
+			<Mod3 />,
+		];
+
+		expect(mount(component).childNodes, "to satisfy", expected);
+
+		expect(mockHistoryPush, "to have calls satisfying", [{ args: ["/TestScope/demos"] }]);
+
+		expect(store.dispatch, "to have a call satisfying", { args: [{ type: SET_ROUTING_PERFORMED }] });
+	});
+
+	it("renders a module table when routing cannot be performed without visible modules", () => {
+		const history = createMemoryHistory({ initialEntries: ["/TestScope/demos?arg=data"] });
+		const mockHistoryPush = sinon.spy(history, "push");
+
+		const component = (
+			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
+				<Modules modules={modules} scope="TestScope" />
+			</TestWrapper>
+		);
+
+		state = state.setIn(["modules", "visibleModules"], Immutable.fromJS([]));
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "moduleName"], "photos");
+
+		mount(component);
+
+		expect(mockHistoryPush, "not to have calls satisfying", [{ args: ["/TestScope/photos"] }]);
+
+		expect(store.dispatch, "not to have calls satisfying", [{ args: [{ type: SET_ROUTING_PERFORMED }] }]);
+	});
+
 	it("renders a module table as a routing system (user route)", () => {
 		const module = {
 			icon: "user",
@@ -270,6 +427,80 @@ describe("Modules", () => {
 		);
 	});
 
+	it("properly sets visible modules and scope when not already set", () => {
+		modules.users.hide = () => () => true;
+		modules.demos.hide = false;
+
+		const component = (
+			<TestWrapper
+				provider={{ store }}
+				memoryRouter={{ initialEntries: ["/TestScope/demos"] }}
+				intlProvider
+				stylesProvider
+				muiThemeProvider={{ theme }}
+			>
+				<Modules modules={modules} scope="TestScope" />
+			</TestWrapper>
+		);
+
+		state = state.setIn(["modules", "visibleModules"], Immutable.fromJS([]));
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "moduleName"], null);
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "scope"], null);
+
+		mount(component);
+
+		expect(store.dispatch, "to have a call satisfying", { args: [{ type: SET_MODULE_AS_VISIBLE, payload: "demos" }] });
+
+		expect(store.dispatch, "to have a call satisfying", { args: [{ type: SET_MODULE_AS_VISIBLE, payload: "photos" }] });
+
+		expect(store.dispatch, "not to have calls satisfying", [
+			{ args: [{ type: SET_MODULE_AS_VISIBLE, payload: "users" }] },
+		]);
+
+		expect(store.dispatch, "to have a call satisfying", {
+			args: [{ type: INITIALIZE_FIRST_MODULE_SCOPE, payload: "TestScope" }],
+		});
+	});
+
+	it("Does not set visible modules and scope when route is not yet initialized", () => {
+		modules.users.hide = () => () => true;
+		modules.demos.hide = false;
+
+		state = state.setIn(["navigation", "route", "match", "params", "scope"], null);
+
+		state = state.setIn(["modules", "visibleModules"], Immutable.fromJS([]));
+
+		const component = (
+			<TestWrapper
+				provider={{ store }}
+				memoryRouter={{ initialEntries: ["/TestScope/demos"] }}
+				intlProvider
+				stylesProvider
+				muiThemeProvider={{ theme }}
+			>
+				<Modules modules={modules} scope="TestScope" />
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		expect(store.dispatch, "not to have calls satisfying", [
+			{ args: [{ type: SET_MODULE_AS_VISIBLE, payload: "demos" }] },
+		]);
+
+		expect(store.dispatch, "not to have calls satisfying", [
+			{ args: [{ type: SET_MODULE_AS_VISIBLE, payload: "photos" }] },
+		]);
+
+		expect(store.dispatch, "not to have calls satisfying", [
+			{ args: [{ type: SET_MODULE_AS_VISIBLE, payload: "users" }] },
+		]);
+
+		expect(store.dispatch, "not to have calls satisfying", [
+			{ args: [{ type: INITIALIZE_FIRST_MODULE_SCOPE, payload: "TestScope" }] },
+		]);
+	});
+
 	describe("with custom href", () => {
 		beforeEach(() => {
 			state = Immutable.fromJS({
@@ -286,9 +517,16 @@ describe("Modules", () => {
 				},
 				settings: {
 					defaultScope: "myScope",
+					modules: ["users", "demos", "photos"],
 				},
 				modules: {
 					tree: {},
+					visibleModules: ["users", "demos", "photos"],
+					lastScopeAndModuleSelection: {
+						scope: "TestScope",
+						moduleName: null,
+						routingPerformed: false,
+					},
 				},
 				view: {
 					edit: {
@@ -387,9 +625,16 @@ describe("Modules", () => {
 				},
 				settings: {
 					defaultScope: "TestScope2",
+					modules: ["users", "demos", "photos"],
 				},
 				modules: {
 					tree: {},
+					visibleModules: ["users", "demos", "photos"],
+					lastScopeAndModuleSelection: {
+						scope: "TestScope",
+						moduleName: null,
+						routingPerformed: false,
+					},
 				},
 				view: {
 					edit: {
@@ -440,13 +685,7 @@ describe("Modules", () => {
 });
 
 describe("Module", () => {
-	let config, Page1, store, state;
-
-	const match = {
-		url: "/TestScope/users/page1",
-		path: "/:scope/users/page1",
-		params: { scope: "TestScope" },
-	};
+	let config, Page1, store, state, match;
 
 	let history, pushSpy;
 	beforeAll(() => {
@@ -456,6 +695,12 @@ describe("Module", () => {
 	});
 
 	beforeEach(() => {
+		match = {
+			url: "/TestScope/users/page1",
+			path: "/:scope/users/page1",
+			params: { scope: "TestScope" },
+		};
+
 		config = {
 			label: "Module 1",
 			icon: "user",
@@ -482,6 +727,12 @@ describe("Module", () => {
 			},
 			modules: {
 				tree: {},
+				visibleModules: ["firstModule", "module123"],
+				lastScopeAndModuleSelection: {
+					scope: "TestScope",
+					moduleName: "Profiles",
+					routingPerformed: true,
+				},
 			},
 			view: {
 				edit: {
@@ -523,49 +774,85 @@ describe("Module", () => {
 
 	const theme = createMuiTheme();
 
-	it("Calls pushes to root when unauthorized user trying to access hidden module", () => {
-		//config.hide = false;
+	it("Calls pushes to first module when unauthorized user trying to access hidden module", () => {
 		const component = (
 			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
-				<Module config={config} match={match} path={match.path} location={{}} />
+				<Module id="notVisibleModule" config={config} match={match} path={match.path} location={{}} />
 			</TestWrapper>
 		);
 
 		mount(component);
 
-		expect(history.push, "to have calls satisfying", [{ args: ["/"] }]);
+		expect(history.push, "to have calls satisfying", [{ args: ["/TestScope/firstModule"] }]);
 
 		pushSpy.resetHistory();
 	});
 
-	it("Calls pushes to root when unauthorized user trying to access hidden module and hide property is a function which retrieves false", () => {
+	it("Does not call pushes to first module when unauthorized user trying to access hidden module and hide property is a function which retrieves false", () => {
 		config.hide = () => false;
 
 		const component = (
 			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
-				<Module config={config} match={match} path={match.path} location={{}} />
+				<Module id="firstModule" config={config} match={match} path={match.path} location={{}} />
 			</TestWrapper>
 		);
 
 		mount(component);
 
-		expect(history.push, "not to have calls satisfying", [{ args: ["/"] }]);
+		expect(history.push, "not to have calls satisfying", [{ args: ["/TestScope/firstModule"] }]);
 
 		pushSpy.resetHistory();
 	});
 
-	it("Calls pushes to root when unauthorized user trying to access hidden module and hide property is a function which retrieves true", () => {
+	it("Calls pushes to first module when unauthorized user trying to access hidden module and hide property is a function which retrieves true", () => {
+		config.hide = () => true;
+
+		const component = (
+			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
+				<Module id="notVisibleModule" config={config} match={match} path={match.path} location={{}} />
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		expect(history.push, "to have calls satisfying", [{ args: ["/TestScope/firstModule"] }]);
+
+		pushSpy.resetHistory();
+	});
+
+	it("Does not call pushes to first module when already set to that location", () => {
+		state = state.setIn(["navigation", "route", "match", "url"], "/TestScope/firstModule");
+		state = state.setIn(["navigation", "route", "match", "path"], "/:scope/firstModule");
+
+		config.hide = () => true;
+
+		const component = (
+			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
+				<Module id="notVisibleModule" config={config} match={match} path={match.path} location={{}} />
+			</TestWrapper>
+		);
+
+		mount(component);
+
+		expect(history.push, "not to have calls satisfying", [{ args: ["/TestScope/firstModule"] }]);
+
+		pushSpy.resetHistory();
+	});
+
+	it("Does not call pushes to first module when redirection is not yet completed to new scope", () => {
+		state = state.setIn(["modules", "lastScopeAndModuleSelection", "scope"], "newScope");
+
 		config.hide = () => true;
 
 		const component = (
 			<TestWrapper provider={{ store }} router={{ history }} intlProvider stylesProvider muiThemeProvider={{ theme }}>
-				<Module config={config} match={match} path={match.path} location={{}} />
+				<Module id="notVisibleModule" config={config} match={match} path={match.path} location={{}} />
 			</TestWrapper>
 		);
 
 		mount(component);
 
-		expect(history.push, "to have calls satisfying", [{ args: ["/"] }]);
+		expect(history.push, "not to have calls satisfying", [{ args: ["/TestScope/firstModule"] }]);
 
 		pushSpy.resetHistory();
 	});

package/src/components/Provision.test.js

@@ -6,6 +6,13 @@ import { spyOnConsole } from "../utils/testUtils";
 import Provision from "./Provision";
 import { createTheme } from "@material-ui/core/styles";
 
+jest.mock("../utils/buildUrl", () => {
+	const modExport = {};
+	modExport.loadConfig = () => Promise.resolve({});
+	modExport.buildUrl = () => "URL";
+	return modExport;
+});
+
 const fakeStore = {
 	subscribe: listener => () => {},
 	dispatch: action => action,
@@ -17,8 +24,35 @@ const fakeStore = {
 			authentication: {
 				name: "foo@bar.com",
 			},
+			scopes: {
+				Global: {
+					name: { en: "Global", fr: "Global" },
+					id: "Global",
+					children: ["MyScope"],
+					currency: {
+						displayName: {
+							en: "Euro",
+							fr: "Euro",
+						},
+					},
+					defaultCulture: "en-US",
+				},
+				MyScope: {
+					name: { en: "First child", fr: "Premier fils" },
+					id: "FirstChild",
+					children: ["ChildScope"],
+					parentScopeId: "Global",
+				},
+				ChildScope: {
+					name: { en: "First grandchild", fr: "Premier petit-fils" },
+					id: "FirstGrandchild",
+					parentScopeId: "MyScope",
+				},
+			},
 			settings: {
 				defaultScope: "myScope",
+				loadedModulesScope: ["moduleA", "moduleB"],
+				modules: ["moduleA", "moduleB"],
 			},
 		}),
 	replaceReducer: () => {},

package/src/components/Routing/FullPage.js

@@ -2,7 +2,7 @@ import React from "react";
 import Page from "./Page";
 import SegmentPage from "./SegmentPage";
 
-const FullPage = ({ path, config, location, match, modulePrependPath }) => {
+const FullPage = ({ path, config, location, match, modulePrependPath, isVisible }) => {
 	const { component, componentProps, pages = {}, segments, subpages, entityIdResolver } = config;
 	if (segments) {
 		return (
@@ -26,6 +26,7 @@ const FullPage = ({ path, config, location, match, modulePrependPath }) => {
 			subpages={subpages}
 			location={location}
 			match={match}
+			isVisible={isVisible}
 			modulePrependPath={modulePrependPath}
 		/>
 	);

package/src/components/Routing/FullPage.test.js

@@ -86,6 +86,29 @@ describe("Fullpage", () => {
 			<View2 />,
 		));
 
+	it("does not show a page when not visible", () =>
+		expect(
+			<TestWrapper
+				provider={{ store }}
+				memoryRouter={{ initialEntries: ["/meep/snap/stuff"] }}
+				stylesProvider
+				muiThemeProvider={{ theme }}
+			>
+				<FullPage
+					path="/meep/snap"
+					config={{
+						component: View1,
+					}}
+					isVisible={false}
+					location={{ location: true }}
+					match={{ match: true }}
+				/>
+			</TestWrapper>,
+			"when mounted",
+			"to be",
+			null,
+		));
+
 	it("shows a segment page if segments", () => {
 		const location = {
 			pathname: "/meep/snap/stuff",

package/src/components/Routing/Page.js

@@ -5,8 +5,8 @@ import FullPage from "./FullPage";
 import SubPage from "./SubPage";
 import withWaypointing from "./withWaypointing";
 
-const Page = ({ component: View, path, pages = {}, subpages = {}, modulePrependPath }) => {
-	const WrappedView = useMemo(() => withErrorBoundary(path)(withWaypointing(View)), [path, View]);
+const Page = ({ component: View, path, pages = {}, subpages = {}, modulePrependPath, isVisible = true }) => {
+	const WrappedView = useMemo(() => withErrorBoundary(path)(withWaypointing(View, isVisible)), [path, View, isVisible]);
 	return (
 		<React.Fragment>
 			<Switch>

package/src/components/Routing/Page.test.js

@@ -70,6 +70,26 @@ describe("Page", () => {
 			</TestWrapper>,
 		));
 
+	it("Does not show the page view when its path is matched but not visible", () =>
+		expect(
+			<TestWrapper provider={{ store }} intlProvider={intlProvider} stylesProvider muiThemeProvider={{ theme }}>
+				<MemoryRouter initialEntries={["/nabble"]}>
+					<Page
+						component={View}
+						path="/nabble"
+						isVisible={false}
+						pages={{
+							"/foo": { component: Sub1 },
+							"/bar": { component: Sub2 },
+						}}
+					/>
+				</MemoryRouter>
+			</TestWrapper>,
+			"when mounted",
+			"to equal",
+			null,
+		));
+
 	it("shows nested page when its path is matched", () =>
 		expect(
 			<TestWrapper provider={{ store }} intlProvider={intlProvider} stylesProvider muiThemeProvider={{ theme }}>

package/src/components/Routing/Segment.js

@@ -6,7 +6,7 @@ const Segment = ({ location, match, config, root, modulePrependPath }) => {
 	const { component, componentProps } = config;
 	const path = location.pathname;
 	const View = useMemo(
-		() => withErrorBoundary(path)(withWaypointing(component, componentProps)),
+		() => withErrorBoundary(path)(withWaypointing(component, true, componentProps)),
 		[path, component, componentProps],
 	);
 	return <View location={location} match={match} mapFrom={root} modulePrependPath={modulePrependPath} />;

package/src/components/Routing/withWaypointing.js

@@ -6,7 +6,7 @@ import { setRoute, mapHref, setCurrentPrependPath } from "../../actions/navigati
 import useLoader from "../../hooks/useLoader";
 
 const withWaypointing =
-	(Comp, componentProps = {}) =>
+	(Comp, isVisible = true, componentProps = {}) =>
 	props => {
 		const { match, mapFrom, modulePrependPath } = props;
 		const location = useLocation();
@@ -24,7 +24,7 @@ const withWaypointing =
 		}
 		const cutout = state => selectRouteHref(state) === location.pathname;
 		useLoader(loadActions, cutout);
-		return <Comp {...props} {...componentProps} />;
+		return isVisible ? <Comp {...props} {...componentProps} /> : null;
 	};
 
 export default withWaypointing;