@reltio/components 1.4.2019 → 1.4.2020

package/HierarchyNodeTitle/useEntityDetails.js

@@ -10,6 +10,9 @@ export var useEntityDetails = function (entityUri) {
         setIsLoading(true);
         safePromise(getEntity(entityUri))
             .then(setEntityDetails)
+            .catch(function (error) {
+            console.warn('Failed to load entity', error);
+        })
             .finally(function () { return setIsLoading(false); });
     }, 1000), [entityUri, safePromise]);
     var hideEntityDetails = useCallback(function () {

package/HierarchyNodeTitle/useEntityDetails.test.js

@@ -194,4 +194,32 @@ describe('useEntityDetails', function () {
             }
         });
     }); });
+    it('should catch and handle error when getEntity returns error', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var warnSpy, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    warnSpy = jest.spyOn(global.console, 'warn');
+                    getEntity.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                    result = renderHook(useEntityDetails, { initialProps: entity.uri }).result;
+                    act(function () {
+                        result.current.showEntityDetails();
+                        jest.runAllTimers();
+                    });
+                    expect(getEntity).toHaveBeenCalled();
+                    return [4 /*yield*/, act(function () {
+                            return Promise.resolve();
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(result.current.isLoading).toBe(false);
+                    expect(warnSpy).toHaveBeenCalledWith('Failed to load entity', {
+                        errorCode: 403,
+                        errorMessage: 'Access is denied'
+                    });
+                    warnSpy.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/ProfileBandNavigation/useSearchNavigation.js

@@ -65,7 +65,11 @@ export var useSearchNavigation = function () {
     }, [listenToActions, updateNavigationData, searchNavigationListener]);
     var requestNextPage = useCallback(function (cache, total, index) {
         setLoading(true);
-        safeRequestTotalPromise(searchProvider.requestTotal()).then(function (total) { return updateNavigationData({ total: total }); });
+        safeRequestTotalPromise(searchProvider.requestTotal())
+            .then(function (total) { return updateNavigationData({ total: total }); })
+            .catch(function (error) {
+            console.warn('Failed to load total count of entities', error);
+        });
         var newIndex = index + 1;
         return safeRequestEntitiesPromise(searchProvider.requestEntities(REQUEST_PAGE_SIZE, newIndex))
             .then(function (entities) {
@@ -97,7 +101,11 @@ export var useSearchNavigation = function () {
     }, [searchProvider, updateNavigationData, openEntity]);
     var requestPrevPage = useCallback(function (cache, index) {
         setLoading(true);
-        safeRequestTotalPromise(searchProvider.requestTotal()).then(function (total) { return updateNavigationData({ total: total }); });
+        safeRequestTotalPromise(searchProvider.requestTotal())
+            .then(function (total) { return updateNavigationData({ total: total }); })
+            .catch(function (error) {
+            console.warn('Failed to load total count of entities', error);
+        });
         var newIndex = index - 1;
         var offset = Math.max(0, index - REQUEST_PAGE_SIZE);
         var max = REQUEST_PAGE_SIZE + Math.min(0, index - REQUEST_PAGE_SIZE);
@@ -207,7 +215,7 @@ export var useSearchNavigation = function () {
         if (cache && uri) {
             var cacheIndex = cache.indexOf(uri) - 1;
             stepBackWithCheck(cache, cacheIndex, total, index).catch(function (error) {
-                console.warn("Can't load prev page of search", error);
+                console.warn("Can't load previous page of search", error);
             });
         }
     }, [stepBackWithCheck, cache, uri, total, index]);

package/ProfileBandNavigation/useSearchNavigation.test.js

@@ -534,6 +534,94 @@ describe('useSearchNavigation behavior', function () {
                 }
             });
         }); });
+        it('should catch and handle checkEntity error when checking previous entity', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.checkEntity.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        _a = setUp(), result = _a.result, waitFor = _a.waitFor;
+                        act(function () {
+                            result.current.onPrev();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isPrevDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load previous page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestTotal error when requesting previous entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri3',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 3,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri3' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        act(function () {
+                            result.current.onPrev();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isPrevDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith('Failed to load total count of entities', {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestEntities error when requesting previous entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockResolvedValue(11);
+                        searchProvider.requestEntities.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri3',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 5,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri3' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        act(function () {
+                            result.current.onPrev();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isPrevDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load previous page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('onNext behavior', function () {
         it('should do nothing if cache or uri in searchNavigationData are not specified', function () {
@@ -901,5 +989,93 @@ describe('useSearchNavigation behavior', function () {
                 }
             });
         }); });
+        it('should catch and handle checkEntity error when checking next entity', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.checkEntity.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        _a = setUp(), result = _a.result, waitFor = _a.waitFor;
+                        act(function () {
+                            result.current.onNext();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isNextDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load next page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestTotal error when requesting next entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri5',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 5,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri5' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        act(function () {
+                            result.current.onNext();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isNextDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith('Failed to load total count of entities', {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestEntities error when requesting next entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockResolvedValue(11);
+                        searchProvider.requestEntities.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri5',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 5,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri5' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        act(function () {
+                            result.current.onNext();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isNextDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load next page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
 });

package/cjs/HierarchyNodeTitle/useEntityDetails.js

@@ -13,6 +13,9 @@ var useEntityDetails = function (entityUri) {
         setIsLoading(true);
         safePromise((0, mdm_sdk_1.getEntity)(entityUri))
             .then(setEntityDetails)
+            .catch(function (error) {
+            console.warn('Failed to load entity', error);
+        })
             .finally(function () { return setIsLoading(false); });
     }, 1000), [entityUri, safePromise]);
     var hideEntityDetails = (0, react_1.useCallback)(function () {

package/cjs/HierarchyNodeTitle/useEntityDetails.test.js

@@ -196,4 +196,32 @@ describe('useEntityDetails', function () {
             }
         });
     }); });
+    it('should catch and handle error when getEntity returns error', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var warnSpy, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    warnSpy = jest.spyOn(global.console, 'warn');
+                    mdm_sdk_1.getEntity.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                    result = (0, react_hooks_1.renderHook)(useEntityDetails_1.useEntityDetails, { initialProps: entity.uri }).result;
+                    (0, react_hooks_1.act)(function () {
+                        result.current.showEntityDetails();
+                        jest.runAllTimers();
+                    });
+                    expect(mdm_sdk_1.getEntity).toHaveBeenCalled();
+                    return [4 /*yield*/, (0, react_hooks_1.act)(function () {
+                            return Promise.resolve();
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(result.current.isLoading).toBe(false);
+                    expect(warnSpy).toHaveBeenCalledWith('Failed to load entity', {
+                        errorCode: 403,
+                        errorMessage: 'Access is denied'
+                    });
+                    warnSpy.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/cjs/ProfileBandNavigation/useSearchNavigation.js

@@ -68,7 +68,11 @@ var useSearchNavigation = function () {
     }, [listenToActions, updateNavigationData, searchNavigationListener]);
     var requestNextPage = (0, react_1.useCallback)(function (cache, total, index) {
         setLoading(true);
-        safeRequestTotalPromise(searchProvider.requestTotal()).then(function (total) { return updateNavigationData({ total: total }); });
+        safeRequestTotalPromise(searchProvider.requestTotal())
+            .then(function (total) { return updateNavigationData({ total: total }); })
+            .catch(function (error) {
+            console.warn('Failed to load total count of entities', error);
+        });
         var newIndex = index + 1;
         return safeRequestEntitiesPromise(searchProvider.requestEntities(constants_1.REQUEST_PAGE_SIZE, newIndex))
             .then(function (entities) {
@@ -100,7 +104,11 @@ var useSearchNavigation = function () {
     }, [searchProvider, updateNavigationData, openEntity]);
     var requestPrevPage = (0, react_1.useCallback)(function (cache, index) {
         setLoading(true);
-        safeRequestTotalPromise(searchProvider.requestTotal()).then(function (total) { return updateNavigationData({ total: total }); });
+        safeRequestTotalPromise(searchProvider.requestTotal())
+            .then(function (total) { return updateNavigationData({ total: total }); })
+            .catch(function (error) {
+            console.warn('Failed to load total count of entities', error);
+        });
         var newIndex = index - 1;
         var offset = Math.max(0, index - constants_1.REQUEST_PAGE_SIZE);
         var max = constants_1.REQUEST_PAGE_SIZE + Math.min(0, index - constants_1.REQUEST_PAGE_SIZE);
@@ -210,7 +218,7 @@ var useSearchNavigation = function () {
         if (cache && uri) {
             var cacheIndex = cache.indexOf(uri) - 1;
             stepBackWithCheck(cache, cacheIndex, total, index).catch(function (error) {
-                console.warn("Can't load prev page of search", error);
+                console.warn("Can't load previous page of search", error);
             });
         }
     }, [stepBackWithCheck, cache, uri, total, index]);

package/cjs/ProfileBandNavigation/useSearchNavigation.test.js

@@ -562,6 +562,94 @@ describe('useSearchNavigation behavior', function () {
                 }
             });
         }); });
+        it('should catch and handle checkEntity error when checking previous entity', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.checkEntity.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        _a = setUp(), result = _a.result, waitFor = _a.waitFor;
+                        (0, react_hooks_1.act)(function () {
+                            result.current.onPrev();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isPrevDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load previous page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestTotal error when requesting previous entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri3',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 3,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri3' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        (0, react_hooks_1.act)(function () {
+                            result.current.onPrev();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isPrevDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith('Failed to load total count of entities', {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestEntities error when requesting previous entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockResolvedValue(11);
+                        searchProvider.requestEntities.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri3',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 5,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri3' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        (0, react_hooks_1.act)(function () {
+                            result.current.onPrev();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isPrevDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load previous page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('onNext behavior', function () {
         it('should do nothing if cache or uri in searchNavigationData are not specified', function () {
@@ -929,5 +1017,93 @@ describe('useSearchNavigation behavior', function () {
                 }
             });
         }); });
+        it('should catch and handle checkEntity error when checking next entity', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.checkEntity.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        _a = setUp(), result = _a.result, waitFor = _a.waitFor;
+                        (0, react_hooks_1.act)(function () {
+                            result.current.onNext();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isNextDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load next page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestTotal error when requesting next entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri5',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 5,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri5' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        (0, react_hooks_1.act)(function () {
+                            result.current.onNext();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isNextDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith('Failed to load total count of entities', {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should catch and handle requestEntities error when requesting next entities page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var warnSpy, searchNavigationData, entity, mdmValues, _a, result, waitFor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        warnSpy = jest.spyOn(global.console, 'warn');
+                        searchProvider.requestTotal.mockResolvedValue(11);
+                        searchProvider.requestEntities.mockRejectedValue({ errorCode: 403, errorMessage: 'Access is denied' });
+                        searchNavigationData = {
+                            uri: 'uri5',
+                            cache: ['uri3', 'uri4', 'uri5'],
+                            index: 5,
+                            total: 10,
+                            tenant: 't1'
+                        };
+                        entity = { uri: 'uri5' };
+                        mdmValues = __assign(__assign({}, defaultMdmValues), { searchNavigationData: searchNavigationData, entity: entity });
+                        _a = setUp({ mdmValues: mdmValues }), result = _a.result, waitFor = _a.waitFor;
+                        (0, react_hooks_1.act)(function () {
+                            result.current.onNext();
+                        });
+                        return [4 /*yield*/, waitFor(function () { return expect(result.current.isNextDisabled).toBe(false); })];
+                    case 1:
+                        _b.sent();
+                        expect(warnSpy).toHaveBeenCalledWith("Can't load next page of search", {
+                            errorCode: 403,
+                            errorMessage: 'Access is denied'
+                        });
+                        warnSpy.mockRestore();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2019",
+  "version": "1.4.2020",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",