@steroidsjs/core 3.1.8 → 3.1.9

package/tests/reducers/router/helpers.test.js

@@ -0,0 +1,367 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+var router_1 = require("../../../src/reducers/router");
+var originalEnv = process.env;
+describe('router reducers', function () {
+    var defaultInitialState = {
+        location: null,
+        routesTree: null,
+        routesMap: null,
+        activeIds: null,
+        match: null,
+        params: {},
+        configs: [],
+        data: {},
+        counters: {}
+    };
+    var initialState = __assign({}, defaultInitialState);
+    var getStateWithRoutesMap = function (routesMap) { return (__assign(__assign({}, initialState), { routesMap: __assign({}, routesMap) })); };
+    beforeEach(function () {
+        initialState = __assign({}, defaultInitialState);
+        jest.resetModules();
+        process.env = __assign({}, originalEnv);
+    });
+    describe('buildUrl', function () {
+        var path = '/home/contacts/physics';
+        it('with params', function () {
+            var params = {
+                search: 'Ivan'
+            };
+            var expectedUrl = '/home/contacts/physics?search=Ivan';
+            expect((0, router_1.buildUrl)(path, params)).toBe(expectedUrl);
+        });
+        it('without params', function () {
+            expect((0, router_1.buildUrl)(path)).toBe(path);
+        });
+    });
+    describe('checkIsActive', function () {
+        //TODO checkIsActive with file protocol
+        it('not SSR without file protocol', function () {
+            var pathname = 'home/contacts/it';
+            global.window.location.protocol = 'http:';
+            var item = {
+                exact: true,
+                strict: true,
+                path: pathname
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    hash: '',
+                    query: null,
+                    search: '',
+                    pathname: pathname
+                } });
+            var expectedIsActive = true;
+            expect((0, router_1.checkIsActive)(state, item)).toBe(expectedIsActive);
+        });
+        it('exact:false matches a pathname that only starts with the route path', function () {
+            global.window.location.protocol = 'http:';
+            var item = {
+                exact: false,
+                strict: false,
+                path: '/home'
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    hash: '',
+                    query: null,
+                    search: '',
+                    pathname: '/home/contacts'
+                } });
+            expect((0, router_1.checkIsActive)(state, item)).toBe(true);
+        });
+        it('exact:true does not match a pathname that only starts with the route path', function () {
+            global.window.location.protocol = 'http:';
+            var item = {
+                exact: true,
+                strict: false,
+                path: '/home'
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    hash: '',
+                    query: null,
+                    search: '',
+                    pathname: '/home/contacts'
+                } });
+            expect((0, router_1.checkIsActive)(state, item)).toBe(false);
+        });
+        it('exact:true, strict:false ignores a trailing slash on the pathname', function () {
+            global.window.location.protocol = 'http:';
+            var item = {
+                exact: true,
+                strict: false,
+                path: '/home'
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    hash: '',
+                    query: null,
+                    search: '',
+                    pathname: '/home/'
+                } });
+            expect((0, router_1.checkIsActive)(state, item)).toBe(true);
+        });
+        it('strict:true requires the trailing slash declared on the route path to be present', function () {
+            global.window.location.protocol = 'http:';
+            var item = {
+                exact: true,
+                strict: true,
+                path: '/home/'
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    hash: '',
+                    query: null,
+                    search: '',
+                    pathname: '/home'
+                } });
+            expect((0, router_1.checkIsActive)(state, item)).toBe(false);
+        });
+        it('does not match a completely different pathname', function () {
+            global.window.location.protocol = 'http:';
+            var item = {
+                exact: true,
+                strict: false,
+                path: '/home'
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    hash: '',
+                    query: null,
+                    search: '',
+                    pathname: '/contacts'
+                } });
+            expect((0, router_1.checkIsActive)(state, item)).toBe(false);
+        });
+    });
+    describe('normalizeRoutes', function () {
+        var _a;
+        var component = function () { return null; };
+        var dashboard = 'dashboard';
+        var information = 'information';
+        var activeIds = [dashboard, information];
+        var getExpectedRoutesMap = function (routesMap, route, expectedRoutesTree) {
+            var _a;
+            return (__assign(__assign({}, routesMap), (_a = {}, _a[route.id] = expectedRoutesTree, _a)));
+        };
+        var getExpectedRoutesTree = function (route, items) { return (__assign(__assign({}, route), { component: null, icon: null, roles: [], items: items })); };
+        var routesMap = (_a = {},
+            _a[dashboard] = {
+                id: dashboard,
+                component: component
+            },
+            _a[information] = {
+                id: information,
+                component: component
+            },
+            _a);
+        var state = getStateWithRoutesMap(routesMap);
+        var routeWithoutChildren = {
+            id: 'routeWithoutChildren',
+            title: 'routeWithoutChildren',
+            label: 'routeWithoutChildren',
+            exact: true,
+            strict: true,
+            path: 'home/contacts/routeWithoutChildren',
+            isVisible: true,
+            isNavVisible: true,
+            component: component,
+            componentProps: null
+        };
+        it('without items', function () {
+            var expectedRoutesTree = getExpectedRoutesTree(routeWithoutChildren, null);
+            var expectedRoutesMap = getExpectedRoutesMap(routesMap, routeWithoutChildren, expectedRoutesTree);
+            expect((0, router_1.normalizeRoutes)(state, routeWithoutChildren, activeIds, routesMap)).toEqual(expectedRoutesTree);
+            expect(routesMap).toEqual(expectedRoutesMap);
+        });
+        it('with items as object', function () {
+            var _a;
+            var childRoute = 'childRoute';
+            var items = (_a = {},
+                _a[childRoute] = {
+                    id: childRoute,
+                    exact: true
+                },
+                _a);
+            var routeWithChildren = __assign(__assign({}, routeWithoutChildren), { items: items });
+            var expectedRoutesTree = getExpectedRoutesTree(routeWithChildren, [
+                __assign(__assign({}, (0, router_1.normalizeRoutes)(state, items[childRoute], activeIds, routesMap)), { id: childRoute }),
+            ]);
+            var expectedRoutesMap = getExpectedRoutesMap(routesMap, routeWithChildren, expectedRoutesTree);
+            expect((0, router_1.normalizeRoutes)(state, routeWithChildren, activeIds, routesMap)).toEqual(expectedRoutesTree);
+            expect(routesMap).toEqual(expectedRoutesMap);
+        });
+        it('with items as array', function () {
+            var childRoute = {
+                id: 'childRoute',
+                exact: true
+            };
+            var routeWithChildren = __assign(__assign({}, routeWithoutChildren), { items: [childRoute] });
+            var expectedRoutesTree = getExpectedRoutesTree(routeWithChildren, [
+                __assign({}, (0, router_1.normalizeRoutes)(state, childRoute, activeIds, routesMap)),
+            ]);
+            var expectedRoutesMap = getExpectedRoutesMap(routesMap, routeWithChildren, expectedRoutesTree);
+            expect((0, router_1.normalizeRoutes)(state, routeWithChildren, activeIds, routesMap)).toEqual(expectedRoutesTree);
+            expect(routesMap).toEqual(expectedRoutesMap);
+        });
+    });
+    describe('findRecursive', function () {
+        var defaultPathItems = [
+            {
+                id: 'someRoute1',
+                path: '/some-route1',
+                label: 'someRoute1'
+            },
+            {
+                id: 'someRoute2',
+                path: '/some-route2',
+                label: 'someRoute2'
+            },
+        ];
+        it('with predicate as parentRoute id', function () {
+            var parentRouteId = 'parentRoute';
+            var pathItems = __spreadArray([], defaultPathItems, true);
+            var parentRoute = {
+                id: parentRouteId,
+                path: '/',
+                label: 'parentRoute'
+            };
+            var expectedPathItems = pathItems.concat([parentRoute]);
+            expect((0, router_1.findRecursive)(parentRoute, parentRouteId, pathItems)).toEqual(parentRoute);
+            expect(pathItems).toEqual(expectedPathItems);
+        });
+        it('with predicate as parentRoute id, without pathItems', function () {
+            var parentRouteId = 'parentRoute';
+            var parentRoute = {
+                id: parentRouteId,
+                path: '/',
+                label: 'parentRoute'
+            };
+            expect((0, router_1.findRecursive)(parentRoute, parentRouteId)).toEqual(parentRoute);
+        });
+        it('without predicate and childrenRoutes array', function () {
+            var emptyPredicate = '';
+            var parentRoute = {
+                id: 'parentRoute',
+                path: '/',
+                label: 'parentRoute'
+            };
+            var emptyRoute = null;
+            expect((0, router_1.findRecursive)(parentRoute, emptyPredicate)).toEqual(emptyRoute);
+        });
+        it('with childrenRoutes array and pathItems', function () {
+            var routeId = 'parentRoute';
+            var deepChildRouteId = 'deepRoute';
+            var pathItems = __spreadArray([], defaultPathItems, true);
+            var deepChildRoute = {
+                id: deepChildRouteId,
+                path: '/child/child2',
+                label: 'deepChildRoute'
+            };
+            var childRoute = {
+                id: 'childRoute',
+                label: 'childRoute',
+                path: '/child',
+                items: [deepChildRoute]
+            };
+            var parentRoute = {
+                id: routeId,
+                label: 'parentRoute',
+                path: '/',
+                items: [childRoute]
+            };
+            var expectedPathItems = pathItems.concat([deepChildRoute, childRoute, parentRoute]);
+            expect((0, router_1.findRecursive)(parentRoute, deepChildRouteId, pathItems)).toEqual(childRoute);
+            expect(pathItems).toEqual(expectedPathItems);
+        });
+    });
+    describe('getMatch', function () {
+        it('without currentRoute', function () {
+            var currentRoute = null;
+            var state = __assign({}, initialState);
+            var emptyMatch = null;
+            expect((0, router_1.getMatch)(currentRoute, state)).toBe(emptyMatch);
+        });
+        it('with currentRoute', function () {
+            var _a;
+            var path = '/home/contacts';
+            var currentRoute = {
+                id: 'currentRoute',
+                exact: true,
+                strict: false,
+                path: path
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    pathname: path,
+                    hash: '',
+                    query: {
+                        query1: 'query1'
+                    },
+                    search: ''
+                } });
+            var expectedMatch = {
+                path: path,
+                url: path,
+                isExact: true,
+                params: __assign({}, (_a = state.location) === null || _a === void 0 ? void 0 : _a.query)
+            };
+            expect((0, router_1.getMatch)(currentRoute, state)).toEqual(expectedMatch);
+        });
+        it('with route params extracted from a dynamic path segment', function () {
+            var currentRoute = {
+                id: 'currentRoute',
+                exact: true,
+                strict: false,
+                path: '/users/:id'
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    pathname: '/users/42',
+                    hash: '',
+                    query: {},
+                    search: ''
+                } });
+            var expectedMatch = {
+                path: '/users/:id',
+                url: '/users/42',
+                isExact: true,
+                params: {
+                    id: '42'
+                }
+            };
+            expect((0, router_1.getMatch)(currentRoute, state)).toEqual(expectedMatch);
+        });
+        it('returns null when the route path does not match the current pathname', function () {
+            var currentRoute = {
+                id: 'currentRoute',
+                exact: true,
+                strict: false,
+                path: '/home'
+            };
+            var state = __assign(__assign({}, initialState), { location: {
+                    pathname: '/contacts',
+                    hash: '',
+                    query: {},
+                    search: ''
+                } });
+            expect((0, router_1.getMatch)(currentRoute, state)).toBe(null);
+        });
+    });
+    afterEach(function () {
+        process.env = originalEnv;
+    });
+});

package/tests/reducers/router/reducerMap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/tests/reducers/router/reducerMap.test.js

@@ -0,0 +1,146 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var router_1 = require("../../../src/actions/router");
+var router_2 = __importDefault(require("../../../src/reducers/router"));
+describe('router reducers', function () {
+    var defaultInitialState = {
+        location: null,
+        routesTree: null,
+        routesMap: null,
+        activeIds: null,
+        match: null,
+        params: {},
+        configs: [],
+        data: {},
+        counters: {}
+    };
+    var initialState = __assign({}, defaultInitialState);
+    beforeEach(function () {
+        initialState = __assign({}, defaultInitialState);
+    });
+    it('ROUTER_INIT_ROUTES', function () {
+        var _a;
+        var parentRouteId = 'parentRouteId';
+        var parentRoute = {
+            id: parentRouteId,
+            isNavVisible: true,
+            isVisible: true,
+            items: [],
+            title: 'parentRoute',
+            label: 'parentRoute',
+            icon: null,
+            exact: false,
+            strict: false,
+            path: '',
+            component: null,
+            componentProps: null,
+            roles: []
+        };
+        var action = {
+            type: router_1.ROUTER_INIT_ROUTES,
+            routes: parentRoute
+        };
+        var expectedState = {
+            location: null,
+            routesTree: parentRoute,
+            routesMap: (_a = {},
+                _a[parentRouteId] = parentRoute,
+                _a),
+            activeIds: [],
+            match: null,
+            params: {},
+            configs: [],
+            data: {},
+            counters: {}
+        };
+        expect((0, router_2["default"])(initialState, action)).toEqual(expectedState);
+    });
+    describe('@@router/LOCATION_CHANGE', function () {
+        it('with routesMap', function () {
+            var _a;
+            var parentRouteId = 'parentRouteId';
+            var childRouteId = 'childRouteId';
+            var action = {
+                type: '@@router/LOCATION_CHANGE'
+            };
+            global.window.location.protocol = 'http:';
+            var childRoute = {
+                id: 'childRouteId',
+                isNavVisible: true,
+                isVisible: true,
+                path: 'parentRoute/childrenRoute',
+                exact: true,
+                strict: false
+            };
+            var parentRoute = {
+                id: 'parentRouteId',
+                isNavVisible: true,
+                isVisible: true,
+                path: '/parentRoute',
+                exact: true,
+                strict: false,
+                items: [
+                    childRoute,
+                ]
+            };
+            initialState = __assign(__assign({}, defaultInitialState), { location: {
+                    pathname: '/parentRoute/childrenRoute',
+                    hash: '',
+                    query: {},
+                    search: ''
+                }, routesMap: (_a = {},
+                    _a[parentRouteId] = parentRoute,
+                    _a[childRouteId] = childRoute,
+                    _a), activeIds: ['someRoute1', 'someRoute2'] });
+            var expectedState = __assign(__assign({}, initialState), { activeIds: [], match: null, params: {}, configs: [], data: {}, counters: {}, routesTree: null });
+            expect((0, router_2["default"])(initialState, action)).toEqual(expectedState);
+        });
+        it('without routesMap', function () {
+            var action = {
+                type: '@@router/LOCATION_CHANGE'
+            };
+            global.window.location.protocol = 'http:';
+            initialState = __assign(__assign({}, defaultInitialState), { location: {
+                    pathname: '/parentRoute/childrenRoute',
+                    hash: '',
+                    query: {},
+                    search: ''
+                }, routesMap: {}, activeIds: ['someRoute1', 'someRoute2'] });
+            var expectedState = __assign(__assign({}, initialState), { activeIds: [], match: null, params: {}, configs: [], data: {}, counters: {}, routesTree: null });
+            expect((0, router_2["default"])(initialState, action)).toEqual(expectedState);
+        });
+    });
+    it('ROUTER_SET_PARAMS', function () {
+        var _a;
+        var action = {
+            type: router_1.ROUTER_SET_PARAMS,
+            params: {
+                someParam: true
+            }
+        };
+        initialState = __assign(__assign({}, defaultInitialState), { location: {
+                hash: '',
+                pathname: '',
+                search: '',
+                query: {
+                    megaQuery: 'megaValue'
+                }
+            } });
+        var expectedState = __assign(__assign({}, initialState), { params: __assign(__assign({}, action.params), (_a = initialState.location) === null || _a === void 0 ? void 0 : _a.query) });
+        expect((0, router_2["default"])(initialState, action)).toEqual(expectedState);
+    });
+});

package/tests/setup.d.ts

@@ -0,0 +1 @@
+import 'jest-enzyme';

package/tests/setup.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+/* eslint-disable import/no-extraneous-dependencies */
+require("jest-enzyme");
+var enzyme_adapter_react_17_1 = __importDefault(require("@wojtekmaj/enzyme-adapter-react-17"));
+var enzyme_1 = require("enzyme");
+(0, enzyme_1.configure)({
+    adapter: new enzyme_adapter_react_17_1["default"]()
+});
+global.__ = function (phrase, params) { return phrase; };

package/tests/ui/content/Accordion/AccordionItem.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/tests/ui/content/Accordion/AccordionItem.test.js

@@ -0,0 +1,62 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+require("@testing-library/jest-dom");
+var AccordionItemMockView_1 = __importDefault(require("./AccordionItemMockView"));
+var AccordionItem_1 = __importDefault(require("../../../../src/ui/content/Accordion/AccordionItem"));
+var helpers_1 = require("../../../helpers");
+describe('AccordionItem', function () {
+    var props = {
+        view: AccordionItemMockView_1["default"]
+    };
+    var expectedAccordionItemClass = 'AccordionItemView';
+    it('should be in the document', function () {
+        var container = (0, helpers_1.render)((0, helpers_1.JSXWrapper)(AccordionItem_1["default"], props)).container;
+        var accordionItem = (0, helpers_1.getElementByClassName)(container, expectedAccordionItemClass);
+        expect(accordionItem).toBeInTheDocument();
+    });
+    it('should have correct external style, external className, position, theme, icon, content', function () {
+        var externalStyle = {
+            width: '30px'
+        };
+        var theme = 'light';
+        var position = 'bottom';
+        var externalClassName = 'test-class';
+        var title = 'accordion-title';
+        var content = 'accordion-content';
+        var _a = (0, helpers_1.render)((0, helpers_1.JSXWrapper)(AccordionItem_1["default"], __assign(__assign({}, props), { style: externalStyle, theme: theme, position: position, className: externalClassName, title: title, children: content }))), container = _a.container, getByText = _a.getByText;
+        var accordionItem = (0, helpers_1.getElementByClassName)(container, expectedAccordionItemClass);
+        var accordionIcon = (0, helpers_1.getElementByClassName)(container, "".concat(expectedAccordionItemClass, "__icon"));
+        var accordionTitle = getByText(title);
+        var accordionContent = getByText(content);
+        expect(accordionItem).toHaveStyle(externalStyle);
+        expect(accordionItem).toHaveClass("".concat(expectedAccordionItemClass, "_theme_").concat(theme));
+        expect(accordionItem).toHaveClass("".concat(expectedAccordionItemClass, "_position_").concat(position));
+        expect(accordionItem).toHaveClass("".concat(externalClassName));
+        expect(accordionIcon).toBeInTheDocument();
+        expect(accordionTitle).toBeInTheDocument();
+        expect(accordionContent).toBeInTheDocument();
+    });
+    it('should have external icon', function () {
+        var container = (0, helpers_1.render)((0, helpers_1.JSXWrapper)(AccordionItem_1["default"], __assign(__assign({}, props), { icon: {
+                open: 'default',
+                close: 'default'
+            } }))).container;
+        var accordionIcon = (0, helpers_1.getElementByClassName)(container, 'IconView');
+        expect(accordionIcon).toBeInTheDocument();
+    });
+});
+//TODO Action

package/tests/ui/content/Accordion/AccordionItemMockView.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { IAccordionItemViewProps } from '../../../../src/ui/content/Accordion/Accordion';
+export default function AccordionItemView(props: IAccordionItemViewProps): JSX.Element;