@steroidsjs/core 3.1.8 → 3.1.9

package/tests/actions/modal.test.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var uniqueId_1 = __importDefault(require("lodash-es/uniqueId"));
+var redux_mock_store_1 = __importDefault(require("redux-mock-store"));
+var modal_1 = require("../../src/actions/modal");
+var storeMiddlewareMock_1 = __importDefault(require("../mocks/storeMiddlewareMock"));
+var mockStore = (0, redux_mock_store_1["default"])([storeMiddlewareMock_1["default"]]);
+var store = mockStore({});
+var mockGroup = 'modalGroup3';
+jest.mock('lodash-es/uniqueId', function () { return ({
+    __esModule: true,
+    "default": jest.fn()
+}); });
+describe('auth actions', function () {
+    beforeEach(function () {
+        store.clearActions();
+    });
+    describe('openModal', function () {
+        var modal = function () { return null; };
+        it('with props', function () {
+            var modalId = 'modal5';
+            var modalGroup = 'primary';
+            var props = {
+                modalId: modalId,
+                modalGroup: modalGroup
+            };
+            var expectedActions = [
+                {
+                    type: modal_1.MODAL_OPEN,
+                    id: modalId,
+                    modal: modal,
+                    group: modalGroup,
+                    props: props
+                },
+            ];
+            store.dispatch((0, modal_1.openModal)(modal, props));
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        it('without props', function () {
+            var modalId = 'modal32';
+            var expectedActions = [
+                {
+                    type: modal_1.MODAL_OPEN,
+                    id: modalId,
+                    modal: modal,
+                    group: null,
+                    props: {}
+                },
+            ];
+            uniqueId_1["default"].mockImplementation(function () { return modalId; });
+            store.dispatch((0, modal_1.openModal)(modal));
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+    });
+    describe('modalMarkClosing', function () {
+        it('without group argument', function () {
+            var modalId = 'modal1';
+            var expectedActions = [
+                {
+                    type: modal_1.MODAL_MARK_CLOSING,
+                    id: modalId,
+                    group: null
+                },
+            ];
+            store.dispatch((0, modal_1.modalMarkClosing)(modalId));
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        it('with group argument', function () {
+            var modalId = 'modal2';
+            var expectedActions = [
+                {
+                    type: modal_1.MODAL_MARK_CLOSING,
+                    id: modalId,
+                    group: mockGroup
+                },
+            ];
+            store.dispatch((0, modal_1.modalMarkClosing)(modalId, mockGroup));
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+    });
+    describe('closeModal', function () {
+        it('without group argument', function () {
+            var modalId = 'modal3';
+            var expectedActions = [
+                {
+                    type: modal_1.MODAL_CLOSE,
+                    id: modalId,
+                    group: null
+                },
+            ];
+            store.dispatch((0, modal_1.closeModal)(modalId));
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        it('with group argument', function () {
+            var modalId = 'modal4';
+            var expectedActions = [
+                {
+                    type: modal_1.MODAL_CLOSE,
+                    id: modalId,
+                    group: mockGroup
+                },
+            ];
+            store.dispatch((0, modal_1.closeModal)(modalId, mockGroup));
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+    });
+});

package/tests/actions/notifications.test.d.ts

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

package/tests/actions/notifications.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var redux_mock_store_1 = __importDefault(require("redux-mock-store"));
+var notifications_1 = require("../../src/actions/notifications");
+var storeMiddlewareMock_1 = __importDefault(require("../mocks/storeMiddlewareMock"));
+var mockStore = (0, redux_mock_store_1["default"])([storeMiddlewareMock_1["default"]]);
+var store = mockStore({});
+describe('actions notifications', function () {
+    beforeEach(function () {
+        store.clearActions();
+    });
+    describe('closeNotification', function () {
+        it('without arguments', function () {
+            var expectedActions = [
+                {
+                    type: notifications_1.NOTIFICATIONS_CLOSE,
+                    id: null
+                },
+            ];
+            store.dispatch((0, notifications_1.closeNotification)());
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        it('with id', function () {
+            var id = 'notification3';
+            var expectedActions = [
+                {
+                    type: notifications_1.NOTIFICATIONS_CLOSE,
+                    id: id
+                },
+            ];
+            store.dispatch((0, notifications_1.closeNotification)(id));
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        describe('showNotification', function () {
+            it('with default arguments', function () {
+                var message = 'You won 1000000 dollars';
+                var expectedActions = [
+                    {
+                        type: notifications_1.NOTIFICATIONS_SHOW,
+                        id: '1',
+                        message: message,
+                        notificationType: 'success',
+                        position: 'top-right'
+                    },
+                ];
+                store.dispatch((0, notifications_1.showNotification)(message));
+                expect(store.getActions()).toEqual(expectedActions);
+            });
+            it('with notificationType argument', function () {
+                var message = 'This button will blow up you computer ^_^';
+                var notificationType = 'primary';
+                var expectedActions = [
+                    {
+                        type: notifications_1.NOTIFICATIONS_SHOW,
+                        id: '2',
+                        message: message,
+                        notificationType: notificationType,
+                        position: 'top-right'
+                    },
+                ];
+                store.dispatch((0, notifications_1.showNotification)(message, notificationType));
+                expect(store.getActions()).toEqual(expectedActions);
+            });
+            it('with empty params argument', function () {
+                var message = 'You are the best';
+                var notificationType = 'error';
+                var expectedActions = [{
+                        type: notifications_1.NOTIFICATIONS_SHOW,
+                        id: '3',
+                        message: message,
+                        notificationType: notificationType,
+                        position: 'top-right'
+                    }];
+                store.dispatch((0, notifications_1.showNotification)(message, notificationType, {}));
+                expect(store.getActions()).toEqual(expectedActions);
+            });
+        });
+        describe('setFlashes', function () {
+            it('with filled flashes', function () {
+                var infoMessage = 'This bicycle is 20% off ';
+                var flashes = {
+                    info: infoMessage
+                };
+                var expectedActions = [
+                    {
+                        type: notifications_1.NOTIFICATIONS_SHOW,
+                        id: '4',
+                        message: infoMessage,
+                        notificationType: 'info',
+                        position: 'top-right'
+                    },
+                ];
+                store.dispatch((0, notifications_1.setFlashes)(flashes));
+                expect(store.getActions()).toEqual(expectedActions);
+            });
+            it('with empty flashes', function () {
+                var flashes = {};
+                var expectedActions = [];
+                store.dispatch((0, notifications_1.setFlashes)(flashes));
+                expect(store.getActions()).toEqual(expectedActions);
+            });
+        });
+    });
+});

package/tests/actions/router.test.d.ts

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

package/tests/actions/router.test.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var redux_mock_store_1 = __importDefault(require("redux-mock-store"));
+var router_1 = require("../../src/actions/router");
+var storeMiddlewareMock_1 = __importDefault(require("../mocks/storeMiddlewareMock"));
+var mockStore = (0, redux_mock_store_1["default"])([storeMiddlewareMock_1["default"]]);
+var store = mockStore({});
+describe('actions router', function () {
+    beforeEach(function () {
+        store.clearActions();
+    });
+    it('initRoutes', function () {
+        var routes = {
+            home: '/home',
+            contacts: '/contacts'
+        };
+        var expectedActions = [
+            {
+                type: router_1.ROUTER_INIT_ROUTES,
+                routes: routes
+            },
+        ];
+        store.dispatch((0, router_1.initRoutes)(routes));
+        expect(store.getActions()).toEqual(expectedActions);
+    });
+    it('initParams', function () {
+        var params = {
+            shallow: true,
+            displayUrl: false
+        };
+        var expectedActions = [
+            {
+                type: router_1.ROUTER_SET_PARAMS,
+                params: params
+            },
+        ];
+        store.dispatch((0, router_1.initParams)(params));
+        expect(store.getActions()).toEqual(expectedActions);
+    });
+    it('goToParent without parentRouteId', function () {
+        var level = 2;
+        var expectedActions = [];
+        store.dispatch((0, router_1.goToParent)(level));
+        expect(store.getActions()).toEqual(expectedActions);
+    });
+});
+describe('goToRoute', function () {
+    var mockedStore;
+    var routeId = 'route1';
+    var path = '/some-route';
+    var type = '@@router/CALL_HISTORY_METHOD';
+    var pushPayload = {
+        method: 'push',
+        args: [path]
+    };
+    var replacePayload = {
+        method: 'replace',
+        args: [path]
+    };
+    beforeEach(function () {
+        var _a;
+        store.clearActions();
+        mockedStore = mockStore({
+            router: {
+                routesMap: (_a = {},
+                    _a[routeId] = {
+                        path: path
+                    },
+                    _a)
+            }
+        });
+    });
+    it('without arguments', function () {
+        var expectedActions = [
+            {
+                type: type,
+                payload: pushPayload
+            },
+        ];
+        mockedStore.dispatch((0, router_1.goToRoute)(routeId));
+        expect(mockedStore.getActions()).toEqual(expectedActions);
+    });
+    it('with params', function () {
+        var expectedActions = [
+            {
+                type: type,
+                payload: pushPayload
+            },
+        ];
+        var params = {
+            exact: false,
+            query: 'contacts'
+        };
+        var isReplace = false;
+        mockedStore.dispatch((0, router_1.goToRoute)(routeId, params, isReplace));
+        expect(mockedStore.getActions()).toEqual(expectedActions);
+    });
+    it('with replace', function () {
+        var expectedActions = [
+            {
+                type: type,
+                payload: replacePayload
+            },
+        ];
+        var params = null;
+        var isReplace = true;
+        mockedStore.dispatch((0, router_1.goToRoute)(routeId, params, isReplace));
+        expect(mockedStore.getActions()).toEqual(expectedActions);
+    });
+    it('with params and replace', function () {
+        var expectedActions = [
+            {
+                type: type,
+                payload: replacePayload
+            },
+        ];
+        var params = {
+            exact: false,
+            query: 'contacts'
+        };
+        var isReplace = true;
+        mockedStore.dispatch((0, router_1.goToRoute)(routeId, params, isReplace));
+        expect(mockedStore.getActions()).toEqual(expectedActions);
+    });
+});

package/tests/base/enum.test.d.ts

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

package/tests/base/enum.test.js

@@ -0,0 +1,112 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var Enum_1 = __importDefault(require("../../src/base/Enum"));
+var TestEnum = /** @class */ (function (_super) {
+    __extends(TestEnum, _super);
+    function TestEnum() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TestEnum.getLabels = function () {
+        var _a;
+        return _a = {},
+            _a[this.FIELD_1] = 'label1',
+            _a[this.FIELD_2] = 'label2',
+            _a[this.FIELD_3] = 'label3',
+            _a;
+    };
+    TestEnum.getCssClasses = function () {
+        var _a;
+        return _a = {},
+            _a[this.FIELD_1] = 'orange',
+            _a[this.FIELD_2] = 'white',
+            _a[this.FIELD_3] = 'black',
+            _a;
+    };
+    TestEnum.FIELD_1 = 'field1';
+    TestEnum.FIELD_2 = 'field2';
+    TestEnum.FIELD_3 = 'field3';
+    return TestEnum;
+}(Enum_1["default"]));
+describe('Enum', function () {
+    it('getLabels', function () {
+        var _a;
+        var expectedLabels = (_a = {},
+            _a[TestEnum.FIELD_1] = 'label1',
+            _a[TestEnum.FIELD_2] = 'label2',
+            _a[TestEnum.FIELD_3] = 'label3',
+            _a);
+        expect(TestEnum.getLabels()).toEqual(expectedLabels);
+    });
+    describe('getLabel', function () {
+        it('correct', function () {
+            var expectedResult = 'label1';
+            expect(TestEnum.getLabel(TestEnum.FIELD_1)).toBe(expectedResult);
+        });
+        it('incorrect', function () {
+            var expectedResult = '';
+            expect(TestEnum.getLabel('Test')).toBe(expectedResult);
+        });
+    });
+    it('getKeys', function () {
+        var expectedKeys = [
+            TestEnum.FIELD_1,
+            TestEnum.FIELD_2,
+            TestEnum.FIELD_3,
+        ];
+        expect(TestEnum.getKeys()).toEqual(expectedKeys);
+    });
+    it('getDropdownItems', function () {
+        var expectedDropdownItems = [
+            {
+                label: 'label1',
+                id: TestEnum.FIELD_1
+            },
+            {
+                label: 'label2',
+                id: TestEnum.FIELD_2
+            },
+            {
+                label: 'label3',
+                id: TestEnum.FIELD_3
+            },
+        ];
+        expect(TestEnum.getDropdownItems()).toEqual(expectedDropdownItems);
+    });
+    it('getCssClasses', function () {
+        var _a;
+        var expectedCssClasses = (_a = {},
+            _a[TestEnum.FIELD_1] = 'orange',
+            _a[TestEnum.FIELD_2] = 'white',
+            _a[TestEnum.FIELD_3] = 'black',
+            _a);
+        expect(TestEnum.getCssClasses()).toEqual(expectedCssClasses);
+    });
+    describe('getCssClass', function () {
+        it('correct', function () {
+            var expectedResult = 'orange';
+            expect(TestEnum.getCssClass(TestEnum.FIELD_1)).toEqual(expectedResult);
+        });
+        it('incorrect', function () {
+            var expectedResult = '';
+            expect(TestEnum.getCssClass('Test')).toEqual(expectedResult);
+        });
+    });
+});

package/tests/components/ClientStorageComponent.test.d.ts

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

package/tests/components/ClientStorageComponent.test.js

@@ -0,0 +1,164 @@
+"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 ClientStorageComponent_1 = __importDefault(require("../../src/components/ClientStorageComponent"));
+var mockStorage = {};
+//TODO Cookie Storage
+describe('ClientStorageComponent', function () {
+    var env = process.env;
+    var storageSetItem;
+    var storageGetItem;
+    var storageRemoveItem;
+    var getInstanceClientStorage = function () { return new ClientStorageComponent_1["default"](null, {}); };
+    beforeAll(function () {
+        global.Storage.prototype.setItem = jest.fn(function (key, value) {
+            mockStorage[key] = value;
+        });
+        global.Storage.prototype.getItem = jest.fn(function (key) { return mockStorage[key]; });
+        global.Storage.prototype.removeItem = jest.fn(function (key) { return delete mockStorage[key]; });
+        global.Storage.prototype.mockReset = function (func) { return func.mockReset(); };
+        storageSetItem = global.Storage.prototype.setItem;
+        storageGetItem = global.Storage.prototype.getItem;
+        storageRemoveItem = global.Storage.prototype.removeItem;
+    });
+    beforeEach(function () {
+        mockStorage = {};
+        //Isolate the work of the describe block with environment variables from other tests
+        jest.resetModules();
+        process.env = __assign({}, env);
+    });
+    describe('class fields', function () {
+        it('constants name', function () {
+            var clientStorage = getInstanceClientStorage();
+            var expectedStorageCookie = 'cookie';
+            var expectedStorageLocal = 'local';
+            var expectedStorageSession = 'session';
+            expect(clientStorage.STORAGE_COOKIE).toBe(expectedStorageCookie);
+            expect(clientStorage.STORAGE_LOCAL).toBe(expectedStorageLocal);
+            expect(clientStorage.STORAGE_SESSION).toBe(expectedStorageSession);
+        });
+    });
+    describe('storages', function () {
+        it('localStorage checks', function () {
+            var localStorageAvailableArgument = 'localStorageAvailable';
+            var localStorageValueArgument = '1';
+            var clientStorage = getInstanceClientStorage();
+            expect(localStorage.setItem).toHaveBeenCalledWith(localStorageAvailableArgument, localStorageValueArgument);
+            expect(localStorage.getItem).toHaveBeenCalledWith(localStorageAvailableArgument);
+            expect(localStorage.removeItem).toHaveBeenCalledWith(localStorageAvailableArgument);
+            expect(clientStorage.localStorageAvailable).toBe(true);
+        });
+        it('sessionStorage checks', function () {
+            var sessionStorageAvailableArgument = 'sessionStorageAvailable';
+            var sessionStorageValueArgument = '1';
+            var clientStorage = getInstanceClientStorage();
+            expect(sessionStorage.setItem)
+                .toHaveBeenCalledWith(sessionStorageAvailableArgument, sessionStorageValueArgument);
+            expect(sessionStorage.getItem).toHaveBeenCalledWith(sessionStorageAvailableArgument);
+            expect(sessionStorage.removeItem).toHaveBeenCalledWith(sessionStorageAvailableArgument);
+            expect(clientStorage.sessionStorageAvailable).toBe(true);
+        });
+    });
+    describe('methods', function () {
+        var clientStorage = getInstanceClientStorage();
+        describe('localStorage', function () {
+            var localStorageKey = 'isMonday';
+            var localStorageValue = true;
+            it('set', function () {
+                clientStorage.set(localStorageKey, localStorageValue, clientStorage.STORAGE_LOCAL);
+                expect(localStorage.setItem).toHaveBeenCalledWith(localStorageKey, localStorageValue);
+            });
+            it('get', function () {
+                clientStorage.get(localStorageKey, clientStorage.STORAGE_LOCAL);
+                expect(localStorage.getItem).toHaveBeenCalledWith(localStorageKey);
+            });
+            it('remove', function () {
+                clientStorage.remove(localStorageKey, clientStorage.STORAGE_LOCAL);
+                expect(localStorage.removeItem).toHaveBeenCalledWith(localStorageKey);
+            });
+        });
+        describe('sessionStorage', function () {
+            var sessionStorageKey = 'isMonday';
+            var sessionStorageValue = true;
+            it('set', function () {
+                clientStorage.set(sessionStorageKey, sessionStorageValue, clientStorage.STORAGE_SESSION);
+                expect(sessionStorage.setItem).toHaveBeenCalledWith(sessionStorageKey, sessionStorageValue);
+            });
+            it('get', function () {
+                clientStorage.get(sessionStorageKey, clientStorage.STORAGE_SESSION);
+                expect(sessionStorage.getItem).toHaveBeenCalledWith(sessionStorageKey);
+            });
+            it('remove', function () {
+                clientStorage.remove(sessionStorageKey, clientStorage.STORAGE_SESSION);
+                expect(sessionStorage.removeItem).toHaveBeenCalledWith(sessionStorageKey);
+            });
+        });
+    });
+    describe('_getDomain', function () {
+        var clientStorage;
+        beforeEach(function () {
+            clientStorage = getInstanceClientStorage();
+            jest.spyOn(clientStorage, '_getDomain');
+        });
+        afterEach(function () {
+            jest.restoreAllMocks();
+        });
+        it('should return null if shareBetweenSubdomains is false', function () {
+            clientStorage.shareBetweenSubdomains = false;
+            expect(clientStorage._getDomain()).toBeNull();
+            expect(clientStorage._getDomain).toHaveBeenCalled();
+        });
+        it('should return host domain for subdomains when shareBetweenSubdomains is true', function () {
+            clientStorage.shareBetweenSubdomains = true;
+            Object.defineProperty(window, 'location', {
+                value: {
+                    hostname: 'app.kozhin.dev'
+                },
+                writable: true
+            });
+            expect(clientStorage._getDomain()).toBe('kozhin.dev');
+            expect(clientStorage._getDomain).toHaveBeenCalled();
+        });
+        it('should return null if hostname is localhost', function () {
+            clientStorage.shareBetweenSubdomains = true;
+            Object.defineProperty(window, 'location', {
+                value: {
+                    hostname: 'localhost'
+                },
+                writable: true
+            });
+            expect(clientStorage._getDomain()).toBeNull();
+        });
+        it('should return null if hostname is an IP address', function () {
+            clientStorage.shareBetweenSubdomains = true;
+            Object.defineProperty(window, 'location', {
+                value: {
+                    hostname: '127.0.0.1'
+                },
+                writable: true
+            });
+            expect(clientStorage._getDomain()).toBeNull();
+        });
+    });
+    afterAll(function () {
+        global.Storage.prototype.mockReset(storageGetItem);
+        global.Storage.prototype.mockReset(storageSetItem);
+        global.Storage.prototype.mockReset(storageRemoveItem);
+        delete global.Storage.prototype.mockReset;
+        //Set the value that was before the tests
+        process.env = env;
+    });
+});

package/tests/components/MetricsComponent.test.d.ts

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