@sankhyalabs/core 6.1.0-dev.2 → 6.1.0-dev.4

package/test/dataunit/RecodsSelection.spec.ts

@@ -0,0 +1,229 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { DataType } from "../../src/dataunit/metadata/DataType";
+import { Sort, SortingProvider, SortMode } from "../../src/dataunit/metadata/UnitMetadata";
+import { ExecutionContext } from "../../src/dataunit/state/action/DataUnitAction";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { recordsTest } from "./resources/records";
+
+describe('Records selection', () => {
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit } = createDataUnitMock());
+    });
+
+    describe('getSelectionInfo', () => {
+        it('should return selection records', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = dataUnit.getSelectionInfo();
+            expect(response).toStrictEqual(expect.objectContaining({ records: [recordsTest[0]] }));
+        });
+
+        it('should get all records', async () => {
+            await dataUnit.loadData();
+            const allRecodsLoader = jest.fn().mockReturnValue(recordsTest);
+            dataUnit.allRecordsLoader = allRecodsLoader;
+            dataUnit.selectFirst();
+            const response = dataUnit.getSelectionInfo();
+            const allRecords = response.getAllRecords?.();
+            expect(allRecodsLoader).toHaveBeenCalledWith(dataUnit);
+            expect(allRecords).toStrictEqual(recordsTest);
+        });
+
+        it('should return empty array when loader return invalid value', async () => {
+            await dataUnit.loadData();
+            const allRecodsLoader = jest.fn();
+            dataUnit.allRecordsLoader = allRecodsLoader;
+            dataUnit.selectFirst();
+            const response = dataUnit.getSelectionInfo();
+            const allRecords = response.getAllRecords?.();
+            expect(allRecodsLoader).toHaveBeenCalledWith(dataUnit);
+            expect(allRecords).toStrictEqual([]);
+        });
+
+        it('should return empty array when not has a loader', async () => {
+            await dataUnit.loadData();
+            dataUnit.allRecordsLoader = undefined;
+            dataUnit.selectFirst();
+            const response = dataUnit.getSelectionInfo();
+            const allRecords = response.getAllRecords?.();
+            expect(allRecords).toStrictEqual([]);
+        });
+
+        it('should return sortable records', async () => {
+            const sortingProvider: SortingProvider = {
+                getSort: () => {
+                    const sort: Sort = {
+                        field: 'column_name_1',
+                        dataType: DataType.TEXT,
+                        mode: SortMode.DESC,
+                    };
+                    return [sort];
+                },
+            }
+            dataUnit.sortingProvider = sortingProvider;
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+            const allRecodsLoader = jest.fn().mockReturnValue(recordsTest);
+            dataUnit.allRecordsLoader = allRecodsLoader;
+            dataUnit.selectFirst();
+            const response = dataUnit.getSelectionInfo();
+            const allRecords = response.getAllRecords?.();
+            expect(allRecodsLoader).toHaveBeenCalledWith(dataUnit);
+            expect(allRecords).toStrictEqual(recordsTest);
+        });
+    });
+
+    describe('selectAllRecords', () => {
+        it('should select all records', async () => {
+            await dataUnit.loadData();
+            await dataUnit.selectAllRecords();
+            const response = dataUnit.getSelectionInfo();
+            expect(response).toStrictEqual(expect.objectContaining({ records: recordsTest }));
+        });
+    });
+
+    describe('unSelectAllRecords', () => {
+        it('should remove all records selection', async () => {
+            await dataUnit.loadData();
+            await dataUnit.selectAllRecords();
+            await dataUnit.unSelectAllRecords();
+            const response = dataUnit.getSelectionInfo();
+            expect(response).toStrictEqual(expect.objectContaining({ records: [] }));
+        });
+    });
+
+    describe('clearSelection', () => {
+        it('should remove all records selection', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            dataUnit.clearSelection();
+            const response = dataUnit.getSelectionInfo();
+            expect(response).toStrictEqual(expect.objectContaining({ records: [] }));
+        });
+    });
+
+    describe('updatePageSelection', () => {
+        it('should set records selection', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = await dataUnit.updatePageSelection([recordsTest[4].__record__id__]);
+            expect(response).toStrictEqual(expect.objectContaining({ records: [recordsTest[4]] }));
+        });
+
+        it('should remove all records selection', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = await dataUnit.updatePageSelection([]);
+            expect(response).toStrictEqual(expect.objectContaining({ records: [] }));
+        });
+
+        it('should remove all records selection', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = await dataUnit.updatePageSelection();
+            expect(response).toStrictEqual(expect.objectContaining({ records: [recordsTest[0]] }));
+        });
+    });
+
+    describe('hasNext', () => {
+        it('should return true when has a next record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = dataUnit.hasNext();
+            expect(response).toBeTruthy();
+        });
+
+        it('should return false when not has a next record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectLast();
+            const response = dataUnit.hasNext();
+            expect(response).toBeFalsy();
+        });
+    });
+
+    describe('hasPrevious', () => {
+        it('should return true when has a prevous record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = dataUnit.hasPrevious();
+            expect(response).toBeFalsy();
+        });
+
+        it('should return false when not has a prevous record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectLast();
+            const response = dataUnit.hasPrevious();
+            expect(response).toBeTruthy();
+        });
+    });
+
+    describe('nextRecord', () => {
+        it('should change selection to second record when has a next in the same page', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            await dataUnit.nextRecord();
+            const response = dataUnit.getSelectionInfo();
+            expect(response.records).toStrictEqual([recordsTest[1]]);
+        });
+
+        it('should change selection to second record when not has a next in the same page', async () => {
+            dataUnit.pageSize = 2;
+            await dataUnit.loadData();
+            dataUnit.selectLast();
+            await dataUnit.nextRecord();
+            const response = dataUnit.getSelectionInfo();
+            expect(response.records).toStrictEqual([recordsTest[2]]);
+        });
+
+        it('should call executionCtx', async () => {
+            dataUnit.pageSize = 2;
+            await dataUnit.loadData();
+            dataUnit.selectLast();
+            const executionCtx: ExecutionContext = {
+                before: jest.fn((value) => value),
+            }
+            await dataUnit.nextRecord(executionCtx);
+            const response = dataUnit.getSelectionInfo();
+            expect(response.records).toStrictEqual([recordsTest[2]]);
+            expect(executionCtx.before).toHaveBeenCalled();
+        });
+    });
+
+    describe('previousRecord', () => {
+        it('should change selection to first record when has a previous in the same page', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectLast();
+            await dataUnit.previousRecord();
+            const response = dataUnit.getSelectionInfo();
+            expect(response.records).toStrictEqual([recordsTest[3]]);
+        });
+
+        it('should change selection to first record when not has a previous in the same page', async () => {
+            dataUnit.pageSize = 2;
+            await dataUnit.loadData();
+            await dataUnit.gotoPage(1);
+            dataUnit.selectFirst();
+            await dataUnit.previousRecord();
+            const response = dataUnit.getSelectionInfo();
+            expect(response.records).toStrictEqual([recordsTest[1]]);
+        });
+
+        it('should call executionCtx', async () => {
+            dataUnit.pageSize = 2;
+            await dataUnit.loadData();
+            await dataUnit.gotoPage(1);
+            dataUnit.selectFirst();
+            const executionCtx: ExecutionContext = {
+                before: jest.fn((value) => value),
+            }
+            await dataUnit.previousRecord(executionCtx);
+            const response = dataUnit.getSelectionInfo();
+            expect(response.records).toStrictEqual([recordsTest[1]]);
+            expect(executionCtx.before).toHaveBeenCalled();
+        });
+    });
+});

package/test/dataunit/RecordsManager.spec.ts

@@ -0,0 +1,323 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { SelectionMode } from "../../src/dataunit/interfaces/dataUnit";
+import ErrorException from "../../src/exceptions/ErrorException";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+import { recordsTest } from "./resources/records";
+
+describe('Records manager', () => {
+    let dataUnit: DataUnit;
+    let dataLoaderMock = jest.fn();
+    let metadataLoaderMock = jest.fn();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit, dataLoaderMock, metadataLoaderMock } = createDataUnitMock());
+    });
+
+    describe('removeRecords', () => {
+        it('should remove first record', async () => {
+            await dataUnit.loadData();
+            await dataUnit.removeRecords(["test_1"], [recordsTest[0]]);
+            expect(dataUnit.records).toStrictEqual(recordsTest.slice(1, recordsTest.length));
+        });
+
+        it('should remove first record with loader', async () => {
+            dataUnit.removeLoader = jest.fn((_, ids) => new Promise<string[]>(resolve => resolve(ids)))
+            await dataUnit.loadData();
+            await dataUnit.removeRecords(["test_1"], [recordsTest[0]]);
+            expect(dataUnit.records).toStrictEqual(recordsTest.slice(1, recordsTest.length));
+            expect(dataUnit.removeLoader).toHaveBeenCalled();
+        });
+
+        it('should remove two record with loader', async () => {
+            dataUnit.removeLoader = jest.fn((_, ids) => new Promise<string[]>(resolve => resolve(ids)))
+            await dataUnit.loadData();
+            await dataUnit.removeRecords(["test_2", "test_1"], [recordsTest[1], recordsTest[0]]);
+            expect(dataUnit.records).toStrictEqual(recordsTest.slice(2, recordsTest.length));
+            expect(dataUnit.removeLoader).toHaveBeenCalled();
+        });
+
+        it('should remove last', async () => {
+            dataUnit.removeLoader = jest.fn((_, ids) => new Promise<string[]>(resolve => resolve(ids)))
+            await dataUnit.loadData();
+            await dataUnit.removeRecords(["test_5"], [recordsTest[4]]);
+            expect(dataUnit.records).toStrictEqual(recordsTest.slice(0, 4));
+        });
+
+        it('should handle error dataLoader', async () => {
+            dataUnit.removeLoader = jest.fn().mockRejectedValue(new Error("Error test"));
+            const removeRecords = async () => await dataUnit.removeRecords(["test_1"], [recordsTest[0]]);
+            await expect(removeRecords()).rejects.toBeInstanceOf(ErrorException);
+        });
+    });
+
+    describe('removeSelectedRecords', () => {
+        it('should remove first record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = await dataUnit.removeSelectedRecords();
+            expect(dataUnit.records).toStrictEqual(recordsTest.slice(1, recordsTest.length));
+            expect(response).toStrictEqual(["test_1"]);
+        });
+
+        it('should remove last record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectLast();
+            const response = await dataUnit.removeSelectedRecords();
+            expect(dataUnit.records).toStrictEqual(recordsTest.slice(0, 4));
+            expect(response).toStrictEqual(["test_5"]);
+        });
+
+        it('should ignore when not has a record selected', async () => {
+            await dataUnit.loadData();
+            const response = await dataUnit.removeSelectedRecords();
+            expect(dataUnit.records).toStrictEqual(recordsTest);
+            expect(response).toStrictEqual([]);
+        });
+
+        it('should throw error when all records is selected', async () => {
+            await dataUnit.loadData();
+            await dataUnit.setSelection(SelectionMode.ALL_RECORDS);
+            const removeSelectedRecords = async () => await dataUnit.removeSelectedRecords();
+            await expect(removeSelectedRecords()).rejects.toBeInstanceOf(Error);
+        });
+    });
+
+    describe('copySelected', () => {
+        it('should copy first record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            dataUnit.copySelected();
+            expect(dataUnit.records.length).toBe(recordsTest.length + 1);
+            expect(dataUnit.records[dataUnit.records.length - 1].__record__id__).toBe("NEW_0");
+            expect(dataUnit.records[dataUnit.records.length - 1].__record__source__id__).toBe("test_1");
+            expect(dataUnit.records[dataUnit.records.length - 1].__copy__).toBeTruthy();
+            expect(dataUnit.records[dataUnit.records.length - 1]).toStrictEqual(expect.objectContaining({
+                column_name_1: 'column_value_1',
+                column_name_2: 1,
+            }));
+        });
+
+        it('should copy last record', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectLast();
+            dataUnit.copySelected();
+            expect(dataUnit.records[dataUnit.records.length - 1].__record__source__id__).toBe("test_5");
+        });
+
+        it('should ignore when not has a record selected', async () => {
+            await dataUnit.loadData();
+            dataUnit.copySelected();
+            expect(dataUnit.records).toStrictEqual(recordsTest);
+        });
+
+        it('should ignore when not has records', async () => {
+            dataUnit.copySelected();
+            expect(dataUnit.records).toStrictEqual([]);
+        });
+
+        it('should throw error when all records is selected', async () => {
+            await dataUnit.loadData();
+            await dataUnit.setSelection(SelectionMode.ALL_RECORDS);
+            expect(() => dataUnit.copySelected()).toThrow("Erro interno: Impossível copiar os registros selecionados pois a seleção atual é virtual.");
+        });
+    });
+
+    describe('hasCopiedRecord', () => {
+        it('should be true when has new records', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            dataUnit.copySelected();
+            const hasCopiedRecord = dataUnit.hasCopiedRecord();
+            expect(hasCopiedRecord).toBeTruthy();
+        });
+
+        it('should be false when not have any record', async () => {
+            dataUnit.copySelected();
+            const hasCopiedRecord = dataUnit.hasCopiedRecord();
+            expect(hasCopiedRecord).toBeFalsy();
+        });
+
+        it('should be false when not have any new record', async () => {
+            await dataUnit.loadData();
+            const hasCopiedRecord = dataUnit.hasCopiedRecord();
+            expect(hasCopiedRecord).toBeFalsy();
+        });
+
+        it('should be false when has new value created', async () => {
+            await dataUnit.addRecord();
+            const hasCopiedRecord = dataUnit.hasCopiedRecord();
+            expect(hasCopiedRecord).toBeFalsy();
+        });
+    });
+
+    describe('reloadCurrentRecord', () => {
+        it('should return empty array when not has recordLoader', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const response = await dataUnit.reloadCurrentRecord();
+            expect(response).toStrictEqual([]);
+        });
+
+        it('should return empty array when not has dataLoader', async () => {
+            dataUnit.dataLoader = undefined;
+            dataUnit.recordLoader = jest.fn().mockResolvedValue({ records: recordsTest });
+            const response = await dataUnit.reloadCurrentRecord();
+            expect(response).toStrictEqual([]);
+        });
+
+        it('should call dataLoader to fech records', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const recordLoader = jest.fn().mockResolvedValue(recordsTest);
+            dataUnit.recordLoader = recordLoader;
+
+            const response = await dataUnit.reloadCurrentRecord();
+            expect(response).toStrictEqual(recordsTest);
+            expect(recordLoader).toHaveBeenCalledWith(dataUnit, ["test_1"]);
+        });
+
+        it('should handle error recordLoader', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            const recordLoader = jest.fn().mockRejectedValue(new Error("Error test"));
+            dataUnit.recordLoader = recordLoader;
+
+            const reloadCurrentRecord = () => dataUnit.reloadCurrentRecord();
+            await expect(reloadCurrentRecord).rejects.toBeInstanceOf(ErrorException);
+        });
+    });
+
+    describe('getModifiedRecords', () => {
+        it('should return record that has been modified', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            dataUnit.setFieldValue('column_name_1', 'new_value');
+            const response = dataUnit.getModifiedRecords();
+            expect(response).toStrictEqual([{ ...recordsTest[0], column_name_1: 'new_value' }]);
+        });
+
+        it('should return empty when not has any record modified', async () => {
+            await dataUnit.loadData();
+            const response = dataUnit.getModifiedRecords();
+            expect(response).toStrictEqual([]);
+        });
+    });
+
+    describe('getAddedRecords', () => {
+        it('should return the new record has been created', async () => {
+            await dataUnit.loadData();
+            await dataUnit.addRecord();
+            const response = dataUnit.getAddedRecords();
+            expect(response).toStrictEqual([{ "__record__id__": "NEW_0", }]);
+        });
+
+        it('should return undefined when not has any new record', async () => {
+            await dataUnit.loadData();
+            const response = dataUnit.getAddedRecords();
+            expect(response).toBeUndefined();
+        });
+    });
+
+    describe('getLastLoadRequest', () => {
+        it('should return a empty request', async () => {
+            await dataUnit.loadData();
+            const response = dataUnit.getLastLoadRequest();
+            expect(response).toStrictEqual({
+                filters: undefined,
+                keepSelection: undefined,
+                parentRecordId: undefined,
+                sort: [],
+                source: undefined,
+            });
+        });
+
+        it('should return a fully example request', async () => {
+            const params = {
+                checkLastFilter: true,
+                keepSelection: true,
+                quickFilter: {
+                    filter: {
+                        expression: 'test',
+                        name: 'test',
+                        params: []
+                    },
+                    term: 'test',
+                },
+                selectFirstRecord: true,
+                source: 'test'
+            }
+            await dataUnit.loadDataWithParams(params);
+            const response = dataUnit.getLastLoadRequest();
+            expect(response).toStrictEqual({
+                filters: [params.quickFilter.filter],
+                keepSelection: true,
+                quickFilter: params.quickFilter,
+                parentRecordId: undefined,
+                sort: [],
+                source: 'test'
+            });
+        });
+    });
+
+    describe('clearDataUnit', () => {
+        it('should clean all records', async () => {
+            await dataUnit.loadData();
+            expect(dataUnit.records).toStrictEqual(recordsTest);
+            dataUnit.clearDataUnit();
+            expect(dataUnit.records).toStrictEqual([]);
+        });
+    });
+
+    describe('cancelEdition', () => {
+        it('should cancel edition', async () => {
+            await dataUnit.loadData();
+            dataUnit.selectFirst();
+            dataUnit.setFieldValue('column_name_1', 'new_value');
+            const response = await dataUnit.cancelEdition();
+            expect(dataUnit.isDirty()).toBeFalsy();
+            expect(response).toBeTruthy();
+        });
+
+        it('should cancel edition in child dataUnits', async () => {
+            const parentDataUnit = new DataUnit();
+            const childDataUnit = parentDataUnit.getChildDataunit('test');
+            dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
+            childDataUnit.dataLoader = dataLoaderMock;
+            parentDataUnit.dataLoader = dataLoaderMock;
+            await childDataUnit.loadData();
+            await parentDataUnit.loadData();
+
+            childDataUnit.selectFirst();
+            await childDataUnit.setFieldValue('column_name_1', 'new_value');
+            await parentDataUnit.setFieldValue('column_name_1', 'new_value');
+
+            const response = await parentDataUnit.cancelEdition();
+            expect(childDataUnit.isDirty()).toBeFalsy();
+            expect(parentDataUnit.isDirty()).toBeFalsy();
+            expect(response).toBeTruthy();
+        });
+
+        it('should load data when cancel edition in child dataUnits and has a record selected', async () => {
+            const parentDataUnit = new DataUnit();
+            const childDataUnit = parentDataUnit.getChildDataunit('test');
+            dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
+            childDataUnit.dataLoader = dataLoaderMock;
+            parentDataUnit.dataLoader = dataLoaderMock;
+            await childDataUnit.loadData();
+            await parentDataUnit.loadData();
+
+            parentDataUnit.selectFirst();
+            childDataUnit.selectFirst();
+            await childDataUnit.setFieldValue('column_name_1', 'new_value');
+            await parentDataUnit.setFieldValue('column_name_1', 'new_value');
+
+            const response = await parentDataUnit.cancelEdition();
+            expect(childDataUnit.isDirty()).toBeFalsy();
+            expect(parentDataUnit.isDirty()).toBeFalsy();
+            expect(response).toBeTruthy();
+            expect(dataLoaderMock).toHaveBeenCalled();
+        });
+    });
+});