@steroidsjs/core 3.1.8 → 3.1.9

package/tests/hooks/useList.test.js

@@ -0,0 +1,445 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var jsx_runtime_1 = require("react/jsx-runtime");
+require("@testing-library/jest-dom");
+var react_redux_1 = require("react-redux");
+var redux_mock_store_1 = __importDefault(require("redux-mock-store"));
+var list_1 = require("../../src/actions/list");
+var useList_1 = __importStar(require("../../src/hooks/useList")), listHelpers = useList_1;
+var useList_2 = require("../../src/hooks/useList");
+var normalizeEmpty = __importStar(require("../../src/ui/list/Empty/Empty"));
+var layoutNames = __importStar(require("../../src/ui/list/LayoutNames/LayoutNames"));
+var pagination = __importStar(require("../../src/ui/list/Pagination/Pagination"));
+var paginationSize = __importStar(require("../../src/ui/list/PaginationSize/PaginationSize"));
+var helpers_1 = require("../helpers");
+var storeMiddlewareMock_1 = __importDefault(require("../mocks/storeMiddlewareMock"));
+var normalizeSortProps = listHelpers.normalizeSortProps, getDefaultSearchModel = listHelpers.getDefaultSearchModel;
+describe('normalizeSortProps function', function () {
+    it('should return a normalized sort object', function () {
+        var sortProps = {
+            enable: true,
+            attribute: 'sort',
+            defaultValue: 'asc'
+        };
+        var normalizedSortProps = normalizeSortProps(sortProps);
+        expect(normalizedSortProps).toEqual(sortProps);
+    });
+    it('should return a default normalized sort object if sort props is false', function () {
+        var sortProps = false;
+        var expectedNormalizedSortProps = __assign({}, useList_2.defaultConfig.sort);
+        var normalizedSortProps = normalizeSortProps(sortProps);
+        expect(normalizedSortProps).toEqual(expectedNormalizedSortProps);
+    });
+});
+describe('getDefaultSearchModel function', function () {
+    it('should return a default search model object', function () {
+        var parameters = {
+            paginationProps: {
+                enable: true,
+                attribute: 'page',
+                defaultValue: 1
+            },
+            paginationSizeProps: {
+                enable: true,
+                attribute: 'pageSize',
+                defaultValue: 10
+            },
+            sort: {
+                enable: true,
+                attribute: 'sort',
+                defaultValue: 'asc'
+            },
+            layoutNamesProps: {
+                enable: true,
+                attribute: 'layout',
+                defaultValue: 'list'
+            }
+        };
+        var expectedAttributes = [
+            {
+                type: 'number',
+                attribute: 'page',
+                defaultValue: 1
+            },
+            {
+                type: 'number',
+                attribute: 'pageSize',
+                defaultValue: 10
+            },
+            {
+                type: 'string',
+                jsType: 'string[]',
+                attribute: 'sort',
+                defaultValue: 'asc'
+            },
+            {
+                type: 'string',
+                attribute: 'layout',
+                defaultValue: 'list'
+            },
+        ];
+        var searchModel = getDefaultSearchModel(parameters);
+        expect(searchModel).toBeDefined();
+        expect(searchModel.attributes).toEqual(expectedAttributes);
+    });
+    it('should return a default search model object without disabled attributes', function () {
+        var parameters = {
+            paginationProps: {
+                enable: false
+            },
+            paginationSizeProps: {
+                enable: true,
+                attribute: 'pageSize',
+                defaultValue: 10
+            },
+            sort: {
+                enable: false
+            },
+            layoutNamesProps: {
+                enable: true,
+                attribute: 'layout',
+                defaultValue: 'list'
+            }
+        };
+        var expectedEnabledAttributes = [
+            {
+                type: 'number',
+                attribute: 'pageSize',
+                defaultValue: 10
+            },
+            {
+                type: 'string',
+                attribute: 'layout',
+                defaultValue: 'list'
+            },
+        ];
+        var searchModel = getDefaultSearchModel(parameters);
+        expect(searchModel).toBeDefined();
+        expect(searchModel.attributes).toEqual(expectedEnabledAttributes);
+    });
+    it('should return an empty array if all parameters are disabled', function () {
+        var parameters = {
+            paginationProps: {
+                enable: false
+            },
+            paginationSizeProps: {
+                enable: false
+            },
+            sort: {
+                enable: false
+            },
+            layoutNamesProps: {
+                enable: false
+            }
+        };
+        var expectedEmptyAttributes = [];
+        var searchModel = getDefaultSearchModel(parameters);
+        expect(searchModel).toBeDefined();
+        expect(searchModel.attributes).toEqual(expectedEmptyAttributes);
+    });
+});
+var normalizeSortPropsSpy = jest.spyOn(listHelpers, 'normalizeSortProps');
+var getDefaultSearchModelSpy = jest.spyOn(listHelpers, 'getDefaultSearchModel');
+var createInitialValuesSpy = jest.spyOn(listHelpers, 'createInitialValues');
+var normalizeEmptyPropsSpy = jest.spyOn(normalizeEmpty, 'normalizeEmptyProps');
+var normalizePaginationSizePropsSpy = jest.spyOn(paginationSize, 'normalizePaginationSizeProps');
+var normalizePaginationPropsSpy = jest.spyOn(pagination, 'normalizePaginationProps');
+var normalizeLayoutNamesPropsSpy = jest.spyOn(layoutNames, 'normalizeLayoutNamesProps');
+jest.mock('react-redux', function () { return (__assign(__assign({ __esModule: true }, jest.requireActual('react-redux')), { useSelector: jest.fn() })); });
+var dispatch = jest.fn();
+var observerMiddleware = function () { return function (next) { return function (action) {
+    if (dispatch) {
+        dispatch(action);
+    }
+    return next(action);
+}; }; };
+var mockStore = (0, redux_mock_store_1["default"])([observerMiddleware, storeMiddlewareMock_1["default"]]);
+var mockedUseSelector = react_redux_1.useSelector;
+var implementMockedUseSelectorWithStore = function (store) { return mockedUseSelector.mockImplementationOnce(function (callback) { return callback(store); }); };
+describe('useList hook', function () {
+    var _a, _b;
+    beforeEach(function () { return jest.clearAllMocks(); });
+    afterAll(function () { return jest.restoreAllMocks(); });
+    var expectedInstanceOfObject = Object;
+    var listId = 'list-id';
+    var mockedListData = 'list from store';
+    var mockedListStore = {
+        list: {
+            lists: (_a = {},
+                _a[listId] = mockedListData,
+                _a)
+        }
+    };
+    var mockedFetchedListStore = {
+        list: {
+            lists: (_b = {},
+                _b[listId] = {
+                    isFetched: true
+                },
+                _b)
+        }
+    };
+    var renderUseListWithFetchedList = function (props) {
+        var store = mockStore(__assign({}, mockedFetchedListStore));
+        implementMockedUseSelectorWithStore(mockedFetchedListStore);
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])(__assign({ listId: listId }, props)); }, {
+            store: {
+                store: store
+            }
+        }).result;
+        return result;
+    };
+    var enabledProp = {
+        enable: true
+    };
+    var disabledProp = {
+        enable: false
+    };
+    it('should return an object with properties', function () {
+        var store = mockStore(__assign({}, mockedListStore));
+        implementMockedUseSelectorWithStore(mockedListStore);
+        var expectedPaginationPosition = 'bottom';
+        var expectedPaginationSizePosition = 'top';
+        var expectedLayoutNamesPosition = 'top';
+        var _a = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId
+        }); }, {
+            store: {
+                store: store
+            }
+        }), result = _a.result, rerender = _a.rerender;
+        var _b = result.current, list = _b.list, model = _b.model, searchModel = _b.searchModel, paginationPosition = _b.paginationPosition, paginationSizePosition = _b.paginationSizePosition, layoutNamesPosition = _b.layoutNamesPosition, renderList = _b.renderList, renderEmpty = _b.renderEmpty, renderPagination = _b.renderPagination, renderPaginationSize = _b.renderPaginationSize, renderLayoutNames = _b.renderLayoutNames, renderSearchForm = _b.renderSearchForm, onFetch = _b.onFetch, onSort = _b.onSort;
+        expect(list).toBeDefined();
+        expect(model).toBeNull();
+        expect(searchModel).toBeInstanceOf(expectedInstanceOfObject);
+        expect(paginationPosition).toBe(expectedPaginationPosition);
+        expect(paginationSizePosition).toBe(expectedPaginationSizePosition);
+        expect(layoutNamesPosition).toBe(expectedLayoutNamesPosition);
+        expect(renderList).toBeInstanceOf(Function);
+        expect(renderEmpty).toBeInstanceOf(Function);
+        expect(renderPagination).toBeInstanceOf(Function);
+        expect(renderPaginationSize).toBeInstanceOf(Function);
+        expect(renderLayoutNames).toBeInstanceOf(Function);
+        expect(renderSearchForm).toBeInstanceOf(Function);
+        expect(onFetch).toBeInstanceOf(Function);
+        expect(onSort).toBeInstanceOf(Function);
+    });
+    it('should get list from store', function () {
+        var store = mockStore(__assign({}, mockedListStore));
+        implementMockedUseSelectorWithStore(mockedListStore);
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId
+        }); }, {
+            store: {
+                store: store
+            }
+        }).result;
+        expect(result.current.list).toEqual(mockedListData);
+    });
+    it('should dispatch list init', function () {
+        var expectedPayload = {
+            listId: listId,
+            action: null,
+            actionMethod: 'get',
+            onFetch: undefined,
+            onError: undefined,
+            condition: undefined,
+            scope: undefined,
+            items: null,
+            sourceItems: null,
+            total: undefined,
+            isRemote: true,
+            primaryKey: 'id',
+            formId: listId,
+            loadMore: false,
+            pageAttribute: 'page',
+            pageSizeAttribute: 'pageSize',
+            sortAttribute: 'sort',
+            layoutAttribute: 'layout',
+            hasInfiniteScroll: null,
+            defaultPageValue: 1
+        };
+        var expectedActions = [
+            (0, list_1.listInit)(listId, expectedPayload),
+            expect.any(Function),
+        ];
+        var store = mockStore({});
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId
+        }); }, {
+            store: {
+                store: store
+            }
+        });
+        expect(dispatch).toHaveBeenCalledWith(expectedActions);
+    });
+    it('should dispatch list set items with initial items', function () {
+        var initialItems = [
+            {
+                id: 1,
+                name: 'html'
+            },
+        ];
+        var expectedActions = [
+            expect.any(Object),
+            (0, list_1.listSetItems)(listId, initialItems),
+        ];
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId,
+            initialItems: initialItems
+        }); });
+        expect(dispatch).toHaveBeenCalledWith(expectedActions);
+    });
+    it('should call normalizeSortProps with parameters', function () {
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            sort: enabledProp
+        }); });
+        expect(normalizeSortPropsSpy).toHaveBeenCalledWith(enabledProp);
+    });
+    it('should call normalizeEmptyProps with parameters', function () {
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            empty: enabledProp
+        }); });
+        expect(normalizeEmptyPropsSpy).toHaveBeenCalledWith(enabledProp);
+    });
+    it('should return "Empty" component if empty is enabled', function () {
+        var result = renderUseListWithFetchedList({
+            empty: enabledProp
+        });
+        var renderedEmpty = result.current.renderEmpty();
+        expect(renderedEmpty).toBeInstanceOf(expectedInstanceOfObject);
+    });
+    it('should return null component if empty is disabled', function () {
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            empty: disabledProp
+        }); }).result;
+        var renderedEmpty = result.current.renderEmpty();
+        expect(renderedEmpty).toBeNull();
+    });
+    it('should call normalizePaginationSizeProps with parameters', function () {
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            paginationSize: enabledProp
+        }); });
+        expect(normalizePaginationSizePropsSpy).toHaveBeenCalledWith(enabledProp);
+    });
+    it('should return "PaginationSize" component if pagination size is enabled', function () {
+        var result = renderUseListWithFetchedList({
+            paginationSize: enabledProp
+        });
+        var renderedPaginationSize = result.current.renderPaginationSize();
+        expect(renderedPaginationSize).toBeInstanceOf(expectedInstanceOfObject);
+    });
+    it('should return null if pagination size is disabled', function () {
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            paginationSize: disabledProp
+        }); }).result;
+        var renderedPaginationSize = result.current.renderPaginationSize();
+        expect(renderedPaginationSize).toBeNull();
+    });
+    it('should call normalizePaginationProps with parameters', function () {
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            pagination: enabledProp
+        }); });
+        expect(normalizePaginationPropsSpy).toHaveBeenCalledWith(enabledProp);
+    });
+    it('should return "Pagination" component if pagination is enabled', function () {
+        var result = renderUseListWithFetchedList({
+            pagination: enabledProp
+        });
+        var renderedPagination = result.current.renderPagination();
+        expect(renderedPagination).toBeInstanceOf(expectedInstanceOfObject);
+    });
+    it('should return null if pagination is disabled', function () {
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            pagination: disabledProp
+        }); }).result;
+        var renderedPagination = result.current.renderPagination();
+        expect(renderedPagination).toBeNull();
+    });
+    it('should call normalizeLayoutNamesProps with parameters', function () {
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            layout: enabledProp
+        }); });
+        expect(normalizeLayoutNamesPropsSpy).toHaveBeenCalledWith(enabledProp);
+    });
+    it('should render "LayoutNames"', function () {
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            layout: enabledProp
+        }); }).result;
+        var renderedLayoutNames = result.current.renderLayoutNames();
+        expect(renderedLayoutNames).toBeInstanceOf(expectedInstanceOfObject);
+    });
+    it('should render a search form', function () {
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId
+        }); }).result;
+        var renderedSearchForm = result.current.renderSearchForm();
+        expect(renderedSearchForm).toBeInstanceOf(expectedInstanceOfObject);
+    });
+    it('should call createInitialValues', function () {
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId
+        }); });
+        expect(createInitialValuesSpy).toHaveBeenCalled();
+    });
+    it('should return "renderList" handler to render "Form" component', function () {
+        var mockedChildNode = (0, jsx_runtime_1.jsx)("div", {});
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId
+        }); }).result;
+        var renderList = result.current.renderList;
+        var renderedList = renderList(mockedChildNode);
+        expect(renderedList).toBeInstanceOf(expectedInstanceOfObject);
+    });
+    it('should return a null if model is not exist', function () {
+        var result = (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId,
+            model: 'model'
+        }); }).result;
+        expect(result.current.model).toBeDefined();
+        expect(result.current.model).toBeNull();
+    });
+    it('should call "getDefaultSearchModel"', function () {
+        (0, helpers_1.renderHook)(function () { return (0, useList_1["default"])({
+            listId: listId
+        }); });
+        expect(getDefaultSearchModelSpy).toHaveBeenCalled();
+    });
+});

package/tests/hooks/useModel.test.d.ts

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

package/tests/hooks/useModel.test.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+require("@testing-library/jest-dom");
+var react_1 = require("@testing-library/react");
+var hooks_1 = require("../../src/hooks");
+var useComponents_1 = __importDefault(require("../../src/hooks/useComponents"));
+jest.mock('../../src/hooks/useComponents');
+var mockedUseComponents = useComponents_1["default"];
+describe('useModel Hook', function () {
+    var normalizedModel = {
+        attributes: [{
+                attribute: 'page',
+                defaultValue: 1,
+                hint: null,
+                isRequired: false,
+                isSortable: false,
+                label: null,
+                type: 'number'
+            }],
+        primaryKey: 'id'
+    };
+    var componentsMock = {
+        meta: {
+            normalizeModel: jest.fn().mockImplementation(function (inputModel, defaultModel) {
+                if (defaultModel === void 0) { defaultModel = null; }
+                if (!inputModel && !defaultModel) {
+                    return null;
+                }
+                return normalizedModel;
+            }),
+            getModel: jest.fn().mockReturnValue(null)
+        }
+    };
+    beforeEach(function () {
+        mockedUseComponents.mockReturnValue(componentsMock);
+        jest.clearAllMocks();
+    });
+    it('should call getModel when passed a model string', function () {
+        var mockedStringModel = 'string model';
+        (0, react_1.renderHook)(function () { return (0, hooks_1.useModel)(mockedStringModel); });
+        expect(componentsMock.meta.getModel).toHaveBeenCalledWith(mockedStringModel);
+    });
+    it('should call normalizeModel with getModel value when passed a model is not string', function () {
+        var mockedModel = {
+            model: 'model'
+        };
+        var mockedDefaultModel = {
+            defaultModel: 'defaultModel'
+        };
+        (0, react_1.renderHook)(function () { return (0, hooks_1.useModel)(mockedModel, mockedDefaultModel); });
+        expect(componentsMock.meta.normalizeModel).toHaveBeenCalledWith(mockedModel, mockedDefaultModel);
+    });
+    it('should return null when passed model and default model is null', function () {
+        var mockedModel = null;
+        var mockedDefaultModel = null;
+        var expectedResult = null;
+        var result = (0, react_1.renderHook)(function () { return (0, hooks_1.useModel)(mockedModel, mockedDefaultModel); }).result;
+        expect(result.current).toBe(expectedResult);
+    });
+    it('should return the normalized model', function () {
+        var mockedModel = {
+            model: 'model'
+        };
+        var mockedDefaultModel = {
+            defaultModel: 'defaultModel'
+        };
+        var result = (0, react_1.renderHook)(function () { return (0, hooks_1.useModel)(mockedModel, mockedDefaultModel); }).result;
+        expect(result.current).toBe(normalizedModel);
+    });
+    it('should trigger generate new normalized model only when props changed', function () {
+        var mockedModel = 'testModel';
+        var newMockedModel = 'newTestModel';
+        var expectedCallsBeforeRerender = 1;
+        var expectedCallsAfterRerender = 2;
+        var rerender = (0, react_1.renderHook)(function (_a) {
+            var model = _a.model;
+            return (0, hooks_1.useModel)(model);
+        }, {
+            initialProps: {
+                model: mockedModel
+            }
+        }).rerender;
+        expect(componentsMock.meta.getModel).toHaveBeenCalledWith(mockedModel);
+        expect(componentsMock.meta.getModel).toHaveBeenCalledTimes(expectedCallsBeforeRerender);
+        rerender({
+            model: mockedModel
+        });
+        expect(componentsMock.meta.getModel).toHaveBeenCalledTimes(expectedCallsBeforeRerender);
+        rerender({
+            model: newMockedModel
+        });
+        expect(componentsMock.meta.getModel).toHaveBeenCalledWith(newMockedModel);
+        expect(componentsMock.meta.getModel).toHaveBeenCalledTimes(expectedCallsAfterRerender);
+        expect(newMockedModel).not.toBe(mockedModel);
+    });
+});

package/tests/hooks/useScreen.test.d.ts

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

package/tests/hooks/useScreen.test.js

@@ -0,0 +1,48 @@
+"use strict";
+exports.__esModule = true;
+require("@testing-library/jest-dom");
+var hooks_1 = require("../../src/hooks");
+var helpers_1 = require("../helpers");
+describe('useScreen hook', function () {
+    var renderUseScreen = function () {
+        var result = (0, helpers_1.renderHook)(function () { return (0, hooks_1.useScreen)(); }, {
+            screen: {}
+        }).result;
+        return result;
+    };
+    it('should return default width', function () {
+        var expectedDefaultWidth = 1024;
+        var result = renderUseScreen();
+        expect(result.current.width).toBe(expectedDefaultWidth);
+    });
+    it('should return default phone width', function () {
+        var _a;
+        var expectedPhoneWidth = 320;
+        var result = renderUseScreen();
+        expect((_a = result.current.media) === null || _a === void 0 ? void 0 : _a.phone).toBe(expectedPhoneWidth);
+    });
+    it('should return default tablet width', function () {
+        var _a;
+        var expectedTabletWidth = 768;
+        var result = renderUseScreen();
+        expect((_a = result.current.media) === null || _a === void 0 ? void 0 : _a.tablet).toBe(expectedTabletWidth);
+    });
+    it('should return default desktop width', function () {
+        var _a;
+        var expectedDesktopWidth = 1024;
+        var result = renderUseScreen();
+        expect((_a = result.current.media) === null || _a === void 0 ? void 0 : _a.desktop).toBe(expectedDesktopWidth);
+    });
+    it('parameters must have a correct type', function () {
+        var expectedFunctionType = 'function';
+        var expectedObjectType = 'object';
+        var result = renderUseScreen();
+        var _a = result.current, media = _a.media, setMedia = _a.setMedia, isPhone = _a.isPhone, isTablet = _a.isTablet, isDesktop = _a.isDesktop, getDeviceType = _a.getDeviceType;
+        expect(typeof media).toBe(expectedObjectType);
+        expect(typeof setMedia).toBe(expectedFunctionType);
+        expect(typeof isPhone).toBe(expectedFunctionType);
+        expect(typeof isTablet).toBe(expectedFunctionType);
+        expect(typeof isDesktop).toBe(expectedFunctionType);
+        expect(typeof getDeviceType).toBe(expectedFunctionType);
+    });
+});

package/tests/hooks/useUniqueId.test.d.ts

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

package/tests/hooks/useUniqueId.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var uniqueId_1 = __importDefault(require("lodash-es/uniqueId"));
+var useUniqueId_1 = __importDefault(require("../../src/hooks/useUniqueId"));
+var mountWithApp_1 = __importDefault(require("../mocks/mountWithApp"));
+function MockResultComponent(props) {
+    return (0, jsx_runtime_1.jsx)("div", {});
+}
+function MockComponent(prefix) {
+    return (0, jsx_runtime_1.jsx)(MockResultComponent, { uniqueId: (0, useUniqueId_1["default"])(prefix) });
+}
+jest.mock('lodash-es/uniqueId', function () { return ({
+    __esModule: true,
+    "default": jest.fn()
+}); });
+describe('useUniqueId hook', function () {
+    it('default behavior', function () {
+        var prefix = 'usefulHook_';
+        var expectedUniqueId = "".concat(prefix, "1");
+        uniqueId_1["default"].mockImplementation(function () { return expectedUniqueId; });
+        var wrapper = (0, mountWithApp_1["default"])(MockComponent, prefix);
+        var uniqueId = wrapper.find('MockResultComponent').prop('uniqueId');
+        expect(uniqueId).toBe(expectedUniqueId);
+    });
+});

package/tests/mocks/componentsMock.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="jest" />
+declare const _default: {
+    http: {
+        setAccessToken: jest.Mock<any, any>;
+        removeAccessToken: jest.Mock<any, any>;
+        onLogout: jest.Mock<any, any>;
+        onLogin: jest.Mock<any, any>;
+        send: jest.Mock<any, any>;
+        getAxiosConfig: jest.Mock<any, any>;
+        setCsrfToken: jest.Mock<any, any>;
+        getAccessToken: jest.Mock<any, any>;
+        resetConfig: jest.Mock<any, any>;
+        getUrl: jest.Mock<any, any>;
+        getAxiosInstance: jest.Mock<any, any>;
+        get: jest.Mock<any, any>;
+        post: jest.Mock<any, any>;
+        delete: jest.Mock<any, any>;
+        afterRequest: jest.Mock<any, any>;
+    };
+    meta: {
+        setModel: jest.Mock<any, any>;
+        defaultTypes: {};
+        defaultKey: string;
+        getModel: jest.Mock<any, any>;
+        setType: jest.Mock<any, any>;
+        getType: jest.Mock<any, any>;
+        normalizeName: jest.Mock<any, any>;
+        normalizeModel: jest.Mock<any, any>;
+    };
+};
+export default _default;