@sankhyalabs/core 6.1.0 → 6.2.0-dev.1

package/test/dataunit/InfoManager.spec.ts

@@ -0,0 +1,254 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { DataType } from "../../src/dataunit/metadata/DataType";
+import { SortMode } from "../../src/dataunit/metadata/UnitMetadata";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { recordsTest } from "./resources/records";
+
+describe('Info manager', () => {
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit } = createDataUnitMock());
+    });
+
+    describe('getters and setters', () => {
+        it('should return dataUnit uuid', () => {
+            const response = dataUnit.dataUnitId;
+            expect(response).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+        });
+
+        it('should return isWaitingToReload', () => {
+            let response = dataUnit.isWaitingToReload();
+            expect(response).toBeFalsy();
+            dataUnit.setWaitingToReload(true);
+            response = dataUnit.isWaitingToReload();
+            expect(response).toBeTruthy();
+        });
+
+        it('should return cancelPagination', () => {
+            let response = dataUnit.cancelPagination;
+            expect(response).toBeFalsy();
+            dataUnit.cancelPagination = true;
+            response = dataUnit.cancelPagination;
+            expect(response).toBeTruthy();
+        });
+
+        it('should return isMultipleEdition', () => {
+            let response = dataUnit.isMultipleEdition;
+            expect(response).toBeFalsy();
+            dataUnit.isMultipleEdition = true;
+            response = dataUnit.isMultipleEdition;
+            expect(response).toBeTruthy();
+        });
+
+        it('should return defaultSorting', () => {
+            const sort = {
+                dataType: DataType.BOOLEAN,
+                field: 'test',
+                mode: SortMode.ASC,
+            };
+            let response = dataUnit.getSort();
+            expect(response).toStrictEqual([]);
+            dataUnit.defaultSorting = [sort];
+            response = dataUnit.getSort();
+            expect(response).toStrictEqual([sort]);
+        });
+
+        it('should return pageSize', () => {
+            let response = dataUnit.pageSize;
+            expect(response).toBe(0);
+            dataUnit.pageSize = 10;
+            response = dataUnit.pageSize;
+            expect(response).toBe(10);
+        });
+    });
+
+    describe('waitingForChange', () => {
+        it('should return true for changes field', () => {
+            dataUnit.startChange('column_name_1', {
+                blocking: true,
+                waitmessage: 'test',
+            });
+            const properties = dataUnit.waitingForChange('column_name_1');
+            expect(properties).toBeTruthy();
+        });
+
+        it('should return false for no changes field', () => {
+            const properties = dataUnit.waitingForChange('column_name_2');
+            expect(properties).toBeFalsy();
+        });
+    });
+
+    describe('getInvalidMessage', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return error message from field', () => {
+            const messageTest = 'Error message';
+            dataUnit.setInvalidField('column_name_1', messageTest, 'test_1');
+            const message = dataUnit.getInvalidMessage('test_1', 'column_name_1');
+            expect(message).toBe(messageTest);
+        });
+
+        it('should return undefined when not has any error', () => {
+            const message = dataUnit.getInvalidMessage('test_1', 'column_name_2');
+            expect(message).toBeUndefined();
+        });
+    });
+
+    describe('isDirty', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return true when has data not saved', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            const isDirty = dataUnit.isDirty();
+            expect(isDirty).toBeTruthy();
+        });
+
+        it('should return true when dataUnit child not has data pending', async () => {
+            dataUnit.getChildDataunit('test');
+            const childDataUnit = dataUnit.getChildDataunit('test');
+            childDataUnit.selectFirst();
+            await childDataUnit.setFieldValue('column_name_1', 'new_value');
+            const isDirty = dataUnit.isDirty();
+            expect(isDirty).toBeTruthy();
+        });
+
+        it('should return false when dataUnit child has data not saved and ignoreChildren', async () => {
+            const childDataUnit = new DataUnit('test', dataUnit);
+            childDataUnit.selectFirst();
+            await childDataUnit.setFieldValue('column_name_1', 'new_value');
+            const isDirty = dataUnit.isDirty(true);
+            expect(isDirty).toBeFalsy();
+        });
+    });
+
+    describe('hasDirtyRecords', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
+            dataUnit.saveLoader = saveLoaderMock;
+        });
+
+        it('should return true when any record has data not saved', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.clearSelection();
+            let isDirty = dataUnit.hasDirtyRecords();
+            expect(isDirty).toBeTruthy();
+            dataUnit.selectLast();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            dataUnit.clearSelection();
+            isDirty = dataUnit.hasDirtyRecords();
+            expect(isDirty).toBeTruthy();
+        });
+
+        it('should return false when data has be saved', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            await dataUnit.saveData();
+            const isDirty = dataUnit.hasDirtyRecords();
+            expect(isDirty).toBeFalsy();
+        });
+    });
+
+    describe('isNewRecord', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return false when record is not new', async () => {
+            dataUnit.selectFirst();
+            const recordSelected = dataUnit.getSelectedRecord();
+            const isNewRecord = dataUnit.isNewRecord(recordSelected?.__record__id__!);
+            expect(isNewRecord).toBeFalsy();
+        });
+
+        it('should return true when record is new', async () => {
+            await dataUnit.addRecord();
+            const recordSelected = dataUnit.getSelectedRecord();
+            const isNewRecord = dataUnit.isNewRecord(recordSelected?.__record__id__!);
+            expect(isNewRecord).toBeTruthy();
+        });
+    });
+
+    describe('canUndo', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
+            dataUnit.saveLoader = saveLoaderMock;
+        });
+
+        it('should return true when changes can undo', async () => {
+            await dataUnit.addRecord();
+            const canUndo = dataUnit.canUndo();
+            expect(canUndo).toBeTruthy();
+        });
+
+        it('should return true when field value changes can undo', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            const canUndo = dataUnit.canUndo();
+            expect(canUndo).toBeTruthy();
+        });
+
+        it('should return false when changes can not undo', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            await dataUnit.saveData();
+            const canUndo = dataUnit.canUndo();
+            expect(canUndo).toBeFalsy();
+        });
+    });
+
+    describe('canRedo', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
+            dataUnit.saveLoader = saveLoaderMock;
+        });
+
+        it('should return true when changes can redo', async () => {
+            await dataUnit.addRecord();
+            const canUndo = dataUnit.canUndo();
+            expect(canUndo).toBeTruthy();
+            dataUnit.undo();
+            const canRedo = dataUnit.canRedo();
+            expect(canRedo).toBeTruthy();
+        });
+
+        it('should return true when field value changes can redo', async () => {
+            dataUnit.selectFirst();
+            await dataUnit.setFieldValue('column_name_1', 'new_value');
+            const canUndo = dataUnit.canUndo();
+            expect(canUndo).toBeTruthy();
+            dataUnit.undo();
+            const canRedo = dataUnit.canRedo();
+            expect(canRedo).toBeTruthy();
+        });
+
+        it('should return false when changes can not redo', () => {
+            const canRedo = dataUnit.canRedo();
+            expect(canRedo).toBeFalsy();
+        });
+    });
+
+    describe('toString', () => {
+        it('should return dataUnit name', () => {
+            const name = dataUnit.toString();
+            expect(name).toContain('dataunit?');
+        });
+    });
+});

package/test/dataunit/LoadDataAndMetadata.spec.ts

@@ -0,0 +1,269 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { DUActionInterceptor, LoadDataParams } from "../../src/dataunit/interfaces/dataUnit";
+import { PaginationInfo } from "../../src/dataunit/loading/PaginationInfo";
+import { Action, ExecutionContext } from "../../src/dataunit/state/action/DataUnitAction";
+import ErrorException from "../../src/exceptions/ErrorException";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { metadata } from "./resources/metadata";
+import { recordsTest } from "./resources/records";
+
+describe('Load data and metadata', () => {
+    let dataUnit: DataUnit;
+    let dataLoaderMock = jest.fn();
+    let metadataLoaderMock = jest.fn();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit, dataLoaderMock, metadataLoaderMock } = createDataUnitMock());
+    });
+
+    describe('gotoPage', () => {
+        it('should not call loader when pageSize is not defined', async () => {
+            await dataUnit.gotoPage(2);
+            expect(dataLoaderMock).not.toHaveBeenCalled();
+        });
+
+        it('should pass limit size and offset on request when pageSize is bigger than 0', async () => {
+            dataUnit.pageSize = 1;
+            const dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
+            dataUnit.dataLoader = dataLoaderMock;
+            await dataUnit.loadData();
+            await dataUnit.gotoPage(2);
+            expect(dataLoaderMock).toHaveBeenCalledWith(dataUnit, expect.objectContaining({ limit: 1, offset: 0 }));
+        });
+
+        it('should call loadData when have a next page', async () => {
+            dataUnit.pageSize = 1;
+            const dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
+            dataUnit.dataLoader = dataLoaderMock;
+            await dataUnit.updatePagination({
+                currentPage: 0,
+                firstRecord: 0,
+                hasMore: true,
+                lastRecord: 4,
+                total: 5
+            });
+            const response = await dataUnit.gotoPage(2);
+            expect(dataLoaderMock).toHaveBeenCalled();
+            expect(response).toStrictEqual({ records: recordsTest });
+        });
+
+        it('should return undefined when not have any next page', async () => {
+            dataUnit.pageSize = 1;
+            const dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
+            dataUnit.dataLoader = dataLoaderMock;
+            await dataUnit.updatePagination({
+                currentPage: 5,
+                firstRecord: 0,
+                hasMore: false,
+                lastRecord: 4,
+                total: 5
+            });
+            const response = await dataUnit.gotoPage(6);
+            expect(dataLoaderMock).not.toHaveBeenCalled();
+            expect(response).toBeUndefined();
+        });
+    });
+
+    describe('nextPage', () => {
+        it('should call loadData for the next page', async () => {
+            const dataUnit = new DataUnit();
+            dataUnit.pageSize = 1;
+            const dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
+            dataUnit.dataLoader = dataLoaderMock;
+            await dataUnit.updatePagination({
+                currentPage: 0,
+                firstRecord: 0,
+                hasMore: true,
+                lastRecord: 4,
+                total: 5
+            });
+            const response = await dataUnit.nextPage();
+            expect(dataLoaderMock).toHaveBeenCalledWith(dataUnit, expect.objectContaining({ offset: 1 }));
+            expect(response).toStrictEqual({ records: recordsTest });
+        });
+    });
+
+    describe('previousPage', () => {
+        it('should call loadData for the previous page', async () => {
+            const dataUnit = new DataUnit();
+            dataUnit.pageSize = 1;
+            const dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
+            dataUnit.dataLoader = dataLoaderMock;
+            await dataUnit.updatePagination({
+                currentPage: 1,
+                firstRecord: 0,
+                hasMore: true,
+                lastRecord: 4,
+                total: 5
+            });
+            const response = await dataUnit.previousPage();
+            expect(dataLoaderMock).toHaveBeenCalledWith(dataUnit, expect.objectContaining({ offset: 0 }));
+            expect(response).toStrictEqual({ records: recordsTest });
+        });
+    });
+
+    describe('dataLoader', () => {
+        it('should return records from dataLoader', async () => {
+            const result = await dataUnit.loadData();
+            expect(result.records).toStrictEqual(recordsTest);
+        });
+
+        it('should call dataLoader when loadData is invoked', async () => {
+            dataLoaderMock.mockResolvedValue({ records: [] });
+            dataUnit.dataLoader = dataLoaderMock;
+
+            const result = await dataUnit.loadData();
+            expect(dataLoaderMock).toHaveBeenCalled();
+            expect(result).toEqual({ records: [] });
+        });
+
+        it('should clear dataUnit when parent record is undefined', async () => {
+            dataUnit.selectFirst();
+            const childDataUnit = new DataUnit('child', dataUnit);
+
+            const result = await childDataUnit.loadData();
+
+            expect(childDataUnit.records).toEqual([]);
+            expect(result).toEqual({ records: [] });
+        });
+
+        it('should clear dataUnit when parent record is new', async () => {
+            dataUnit.addRecord();
+            const childDataUnit = new DataUnit('child', dataUnit);
+
+            const result = await childDataUnit.loadData();
+
+            expect(childDataUnit.records).toEqual([]);
+            expect(result).toEqual({ records: [] });
+        });
+
+        it('should pass quickFilter on request', async () => {
+            const quickFilter = { term: 'test' };
+            await dataUnit.loadData(quickFilter);
+            expect(dataLoaderMock).toHaveBeenCalledWith(dataUnit, expect.objectContaining({ quickFilter }));
+        });
+
+        it('should pass limit size and offset on request when pageSize is bigger than 0', async () => {
+            dataUnit.pageSize = 1;
+            await dataUnit.loadData();
+            expect(dataLoaderMock).toHaveBeenCalledWith(dataUnit, expect.objectContaining({ limit: 1, offset: 0 }));
+        });
+
+        it('should avoid call dataLoader when request is the same at the last', async () => {
+            const paginationInfo: PaginationInfo = {
+                currentPage: 0,
+                firstRecord: 0,
+                hasMore: true,
+                lastRecord: 4,
+            };
+            jest.spyOn(dataUnit, 'getPaginationInfo').mockReturnValue(paginationInfo);
+            const response1 = await dataUnit.loadData(undefined, undefined, true, undefined, true);
+            const response2 = await dataUnit.loadData(undefined, undefined, true, undefined, true);
+            const selectedRecord = dataUnit.getSelectedRecord();
+            expect(selectedRecord).toStrictEqual(recordsTest[0]);
+            expect(dataLoaderMock).toHaveBeenCalledTimes(1);
+            expect(response1.records).toStrictEqual(response2.records);
+        });
+
+        it('should select first record when propertie selectFirstRecord is true', async () => {
+            await dataUnit.loadData(undefined, undefined, undefined, undefined, true);
+            const selectedRecord = dataUnit.getSelectedRecord();
+            expect(selectedRecord).toStrictEqual(recordsTest[0]);
+        });
+
+        it('should handle error dataLoader', async () => {
+            dataLoaderMock.mockRejectedValue(new Error("Error test"));
+            const loadData = async () => await dataUnit.loadData();
+            await expect(loadData()).rejects.toBeInstanceOf(ErrorException);
+        });
+    });
+
+    describe('loadDataWithParams', () => {
+        it('should pass params to loadData correctly', async () => {
+            const loadDataMock = jest.spyOn(dataUnit, 'loadData');
+            const executionCtx: ExecutionContext = {
+                before: jest.fn((value) => value),
+                after: jest.fn((value) => value),
+            }
+            const params: LoadDataParams = {
+                checkLastFilter: true,
+                executionCtx,
+                keepSelection: true,
+                quickFilter: { term: 'test' },
+                selectFirstRecord: true,
+                source: 'test'
+            }
+            dataUnit.loadDataWithParams(params);
+            expect(loadDataMock).toHaveBeenCalledWith(
+                params.quickFilter,
+                params.executionCtx,
+                params.checkLastFilter,
+                params.source,
+                params.selectFirstRecord,
+                params.keepSelection
+            );
+        });
+    });
+
+    describe('loadMetadata', () => {
+        it('should return metadata', async () => {
+            const response = await dataUnit.loadMetadata();
+            expect(response).toStrictEqual(metadata);
+        });
+
+        it('should handle error metadataLoader', async () => {
+            metadataLoaderMock.mockRejectedValue(new Error("Error test"));
+            const loadMetadata = async () => await dataUnit.loadMetadata();
+            await expect(loadMetadata()).rejects.toBeInstanceOf(ErrorException);
+        });
+
+        it('should call executionCtx methods', async () => {
+            const executionCtx: ExecutionContext = {
+                before: jest.fn((value) => value),
+                after: jest.fn((value) => value),
+            }
+            await dataUnit.loadMetadata(executionCtx);
+            expect(executionCtx.before).toHaveBeenCalled();
+            expect(executionCtx.after).toHaveBeenCalled();
+        });
+
+        it('should call interceptors', async () => {
+            const loadingMetadata = jest.fn();
+            const metadataLoaded = jest.fn();
+            const interceptor: DUActionInterceptor = {
+                interceptAction: (action) => {
+                    switch (action.type) {
+                        case Action.LOADING_METADATA:
+                            loadingMetadata(action.payload);
+                            break;
+                        case Action.METADATA_LOADED:
+                            metadataLoaded(action.payload);
+                            break;
+                    }
+                    return action;
+                }
+            }
+            dataUnit.addInterceptor(interceptor);
+            const promiseLoadMetadata = dataUnit.loadMetadata();
+
+            expect(loadingMetadata).toHaveBeenCalled();
+            expect(metadataLoaded).not.toHaveBeenCalled();
+            await promiseLoadMetadata;
+
+            expect(metadataLoaded).toHaveBeenCalledWith(metadata);
+        });
+
+        it('should interrupt by executionCtx', async () => {
+            const executionCtx: ExecutionContext = {
+                before: jest.fn(),
+                after: jest.fn(),
+            }
+            await dataUnit.loadMetadata(executionCtx);
+            expect(executionCtx.before).toHaveBeenCalled();
+            expect(executionCtx.after).not.toHaveBeenCalled();
+            expect(dataUnit.metadataLoader).not.toHaveBeenCalled();
+        });
+    });
+});