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

package/src/components/Modules.js

@@ -3,49 +3,122 @@ import { useHistory, useLocation } from "react-router-dom";
 import { useSelector, useDispatch } from "react-redux";
 import { Route, Switch, Redirect } from "react-router-dom";
 import withErrorBoundary from "../hocs/withErrorBoundary";
-import { getCurrentScope, selectRouteHref } from "../selectors/navigation";
+import { getCurrentScope, getCurrentScopeFromRoute, selectRouteHref } from "../selectors/navigation";
 import { isCurrentScopeAuthorizedSelector } from "../selectors/scope";
 import Navigation from "./Navigation";
 import FullPage from "./Routing/FullPage";
 import { setHrefConfig } from "../actions/navigation";
-import { setModulesStructure } from "../actions/modules";
-import { defaultScopeSelector } from "../selectors/settings";
+import {
+	setRoutingPerformed,
+	setModuleAsVisible,
+	setModulesStructure,
+	initializeFirstModuleScope,
+} from "../actions/modules";
+import { defaultScopeSelector, getApplicationModulesSelector } from "../selectors/settings";
+import { getScopeModuleInformationSelector } from "../selectors/modules";
+import UrlPattern from "url-pattern";
+import { overtureModule } from "../constants";
 
-export const Module = withErrorBoundary("Module")(({ config, path, error, location, match, modulePrependPath }) => {
-	const currentRoute = useSelector(selectRouteHref);
+const rerouteOnScopeAndModule = (history, currentRoute, scope, module) => {
+	const params = {
+		scope: scope,
+	};
+
+	const pattern = new UrlPattern(`/:scope/${module}`);
+	const href = pattern.stringify(params);
+
+	if (currentRoute !== href) {
+		history.push(href);
+	}
+};
+
+export const Module = withErrorBoundary("Module")(({ id, config, path, error, location, match, modulePrependPath }) => {
 	const history = useHistory();
-	let hideSelector = state => (typeof config.hide === "function" ? config.hide(state) : config.hide ?? false);
-	const isHidden = useSelector(hideSelector);
+	const scope = useSelector(getCurrentScopeFromRoute);
+	const currentRoute = useSelector(selectRouteHref);
+	const moduleInfo = useSelector(getScopeModuleInformationSelector);
+
+	const isVisible =
+		moduleInfo.scope != null && moduleInfo.visibleModules.length > 0 && moduleInfo.visibleModules.includes(id);
 
 	React.useEffect(() => {
-		if (isHidden === true && currentRoute.includes(match.url)) {
-			history.push("/");
+		if (moduleInfo.scope != null && scope === moduleInfo.scope && moduleInfo.visibleModules.length > 0 && !isVisible) {
+			rerouteOnScopeAndModule(history, currentRoute, moduleInfo.scope, moduleInfo.visibleModules[0]);
 		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [isHidden, currentRoute, match.url]);
+	}, [history, scope, isVisible, currentRoute, moduleInfo.scope, moduleInfo.visibleModules]);
 
 	return (
-		<FullPage path={path} config={config} location={location} match={match} modulePrependPath={modulePrependPath} />
+		<FullPage
+			path={path}
+			config={config}
+			location={location}
+			match={match}
+			modulePrependPath={modulePrependPath}
+			isVisible={isVisible}
+		/>
 	);
 });
 
 const getHrefFromPath = (path, scope) => path.replace(":scope", scope);
 
+const CheckModuleVisibility = ({ id, config, moduleInfo }) => {
+	const dispatch = useDispatch();
+	const applicationModules = useSelector(getApplicationModulesSelector);
+	const scopeFromRoute = useSelector(getCurrentScopeFromRoute);
+
+	const hideSelector = state => (typeof config.hide === "function" ? config.hide(state) : () => config.hide ?? false);
+
+	const isHidden = useSelector(hideSelector(moduleInfo.scope ?? scopeFromRoute));
+
+	const moduleScope = moduleInfo.scope;
+	const moduleIsVisible = isHidden === false && !moduleInfo.visibleModules.includes(id);
+
+	React.useEffect(() => {
+		// We need to wait for the ROUTE to be set the first time in the Redux/Store before to set module's visibility
+		if (scopeFromRoute !== null || applicationModules.includes(overtureModule.System)) {
+			if (moduleScope == null) {
+				dispatch(initializeFirstModuleScope(scopeFromRoute));
+			}
+
+			if (moduleIsVisible) {
+				dispatch(setModuleAsVisible(id));
+			}
+		}
+	}, [moduleScope, moduleIsVisible, dispatch, id, scopeFromRoute, applicationModules]);
+
+	return <React.Fragment />;
+};
+
 export const Modules = ({ modules, pathConfig: { customPath, ...otherConfigs } = {} }) => {
 	const dispatch = useDispatch();
-	const scope = useSelector(getCurrentScope);
+	const currentScope = useSelector(getCurrentScope);
 	const isAuthorizedScope = useSelector(isCurrentScopeAuthorizedSelector);
 	const defaultScope = useSelector(defaultScopeSelector);
 	const history = useHistory();
 	const location = useLocation();
+	const currentRoute = useSelector(selectRouteHref);
+
+	const moduleInfo = useSelector(getScopeModuleInformationSelector);
+
+	const firstModuleName = Object.keys(modules)[0];
+
+	const destinationModule =
+		moduleInfo.routingPerformed === false &&
+		moduleInfo.scope != null &&
+		moduleInfo.visibleModules.length > 0 &&
+		moduleInfo.moduleName != null
+			? moduleInfo.visibleModules.includes(moduleInfo.moduleName)
+				? moduleInfo.moduleName
+				: moduleInfo.visibleModules[0]
+			: null;
 
 	const scopePath = "/:scope/";
 	const prependPath = customPath || scopePath;
-	const prependHref = getHrefFromPath(prependPath, scope);
+	const prependHref = getHrefFromPath(prependPath, currentScope);
 
 	Object.keys(otherConfigs).forEach(key => {
 		const moduleConfig = otherConfigs[key];
-		moduleConfig.prependHref = getHrefFromPath(moduleConfig.prependPath, scope);
+		moduleConfig.prependHref = getHrefFromPath(moduleConfig.prependPath, currentScope);
 	});
 
 	useEffect(() => {
@@ -53,23 +126,33 @@ export const Modules = ({ modules, pathConfig: { customPath, ...otherConfigs } =
 	}, [dispatch, prependPath, prependHref, otherConfigs]);
 
 	const getModuleConfig = name => (otherConfigs && otherConfigs[name]) || { prependPath, prependHref };
-	const firstModuleName = Object.keys(modules)[0];
 
 	useEffect(() => {
 		const { pathname, search } = location;
-		if (!isAuthorizedScope && pathname.includes(scope) && defaultScope) {
-			history.push(pathname.replace(scope, defaultScope) + search);
+		if (!isAuthorizedScope && pathname.includes(currentScope) && defaultScope) {
+			history.push(pathname.replace(currentScope, defaultScope) + search);
 		}
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [isAuthorizedScope, defaultScope, history, scope]);
+	}, [isAuthorizedScope, defaultScope, history, currentScope]);
 
 	React.useEffect(() => {
 		dispatch(setModulesStructure(modules));
 	}, [dispatch, modules]);
 
+	useEffect(() => {
+		if (destinationModule != null) {
+			rerouteOnScopeAndModule(history, currentRoute, moduleInfo.scope, destinationModule);
+
+			dispatch(setRoutingPerformed());
+		}
+	}, [dispatch, history, moduleInfo.scope, destinationModule, currentRoute]);
+
 	return (
 		<React.Fragment>
 			<Navigation modules={modules} />
+			{Object.entries(modules).map(([name, module]) => (
+				<CheckModuleVisibility key={name} id={name} config={module} moduleInfo={moduleInfo} />
+			))}
 			<Switch>
 				{Object.entries(modules).map(([name, module]) => {
 					const moduleConfig = getModuleConfig(name);
@@ -79,7 +162,7 @@ export const Modules = ({ modules, pathConfig: { customPath, ...otherConfigs } =
 							key={name}
 							path={path}
 							render={route => (
-								<Module modulePrependPath={moduleConfig.prependPath} config={module} path={path} {...route} />
+								<Module id={name} modulePrependPath={moduleConfig.prependPath} config={module} path={path} {...route} />
 							)}
 						/>
 					);

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();
 	});