@sankhyalabs/core 6.1.0-dev.4 → 6.1.0-rc.1

package/test/dataunit/RecordsManager.spec.ts

@@ -1,323 +0,0 @@
-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();
-        });
-    });
-});

package/test/dataunit/SavingData.spec.ts

@@ -1,206 +0,0 @@
-import { Change } from "../../src/dataunit/Changes";
-import DataUnit from "../../src/dataunit/DataUnit";
-import { DUActionInterceptor } from "../../src/dataunit/interfaces/dataUnit";
-import { Action, DataUnitAction } from "../../src/dataunit/state/action/DataUnitAction";
-import ErrorException from "../../src/exceptions/ErrorException";
-import ServiceCanceledException from "../../src/exceptions/ServiceCanceledException";
-import SilentException from "../../src/exceptions/SilentException";
-import WaitingChangeException from "../../src/exceptions/WaitingChangeException";
-import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
-import { recordsTest } from "./resources/records";
-
-describe('Saving data', () => {
-    let dataUnit: DataUnit;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
-        ({ dataUnit } = createDataUnitMock());
-    });
-
-    describe('saveData', () => {
-        it('should call saveLoader with a new record', async () => {
-            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
-            dataUnit.saveLoader = saveLoaderMock;
-            await dataUnit.addRecord();
-            await dataUnit.setFieldValue('column_name_1', 'new_value');
-            await dataUnit.saveData();
-            expect(saveLoaderMock).toHaveBeenCalledWith(
-                dataUnit,
-                expect.arrayContaining([
-                    expect.objectContaining({
-                        record: { "__record__id__": "NEW_0" },
-                        updatingFields: { "column_name_1": "new_value" },
-                    })
-                ])
-            );
-        });
-
-        it('should not call saveLoader when not has any data to saved', async () => {
-            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
-            dataUnit.saveLoader = saveLoaderMock;
-            await dataUnit.saveData();
-            expect(saveLoaderMock).not.toHaveBeenCalled();
-        });
-
-        it('should call interceptor dataSaved', async () => {
-            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
-            dataUnit.saveLoader = saveLoaderMock;
-            const dataSaved = jest.fn();
-            const interceptors: DUActionInterceptor = {
-                interceptAction: (action) => {
-                    if (action.type === Action.DATA_SAVED) {
-                        dataSaved();
-                    }
-                    return action;
-                }
-            }
-            dataUnit.addInterceptor(interceptors);
-            await dataUnit.addRecord();
-            await dataUnit.saveData();
-            expect(dataSaved).toHaveBeenCalled();
-        });
-
-        it('should throw error waiting change when has a blocking promise', async () => {
-            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
-            dataUnit.saveLoader = saveLoaderMock;
-            await dataUnit.addRecord();
-            let resolvePromise: Function;
-            dataUnit.startChange("column_name_1", {
-                blocking: true,
-                waitmessage: 'Waiting column change',
-                promise: new Promise((resolve) => {
-                    resolvePromise = resolve;
-                })
-            });
-            const saveData = () => dataUnit.saveData();
-            await expect(saveData).rejects.toBeInstanceOf(WaitingChangeException);
-        });
-
-        it('should waiting change when not has blocking promises', async () => {
-            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
-            dataUnit.saveLoader = saveLoaderMock;
-            let resolvePromise: () => void = () => { };
-            await dataUnit.addRecord();
-            dataUnit.startChange("column_name_1", {
-                blocking: false,
-                waitmessage: 'Waiting column change',
-                promise: new Promise<void>((resolve) => {
-                    resolvePromise = resolve;
-                }),
-            });
-            const promise = dataUnit.saveData();
-            expect(saveLoaderMock).not.toHaveBeenCalled();
-            resolvePromise();
-            await promise;
-            expect(saveLoaderMock).toHaveBeenCalled();
-        });
-
-        it('should just resolve promises when not has a saveLoader', async () => {
-            dataUnit.saveLoader = undefined;
-            await dataUnit.addRecord();
-            dataUnit.startChange("column_name_1", {
-                blocking: false,
-                waitmessage: 'Waiting column change',
-                promise: new Promise<void>((resolve) => {
-                    resolve();
-                }),
-            });
-            const dataSaved = jest.fn();
-            const interceptors: DUActionInterceptor = {
-                interceptAction: (action) => {
-                    if (action.type === Action.DATA_SAVED) {
-                        dataSaved();
-                    }
-                    return action;
-                }
-            }
-            dataUnit.addInterceptor(interceptors);
-            await dataUnit.saveData();
-            expect(dataSaved).not.toHaveBeenCalled();
-        });
-
-        it('should handle error saveLoader', async () => {
-            const saveLoaderMock = jest.fn().mockRejectedValue("Error");
-            dataUnit.saveLoader = saveLoaderMock;
-            const dataSaved = jest.fn();
-            const savingError = jest.fn();
-            const interceptors: DUActionInterceptor = {
-                interceptAction: (action) => {
-                    switch (action.type) {
-                        case Action.DATA_SAVED:
-                            dataSaved();
-                            break;
-                        case Action.SAVING_ERROR:
-                            savingError();
-                            break;
-                    }
-                    return action;
-                }
-            }
-            dataUnit.addInterceptor(interceptors);
-            await dataUnit.addRecord();
-            const saveData = () => dataUnit.saveData();
-            await expect(saveData).rejects.toBeInstanceOf(ErrorException);
-            expect(dataSaved).not.toHaveBeenCalled();
-        });
-
-        it('should handle error ServiceCanceledException saveLoader', async () => {
-            const saveLoaderMock = jest.fn().mockRejectedValue(new ServiceCanceledException("Caceled", "Test canceled"));
-            dataUnit.saveLoader = saveLoaderMock;
-            await dataUnit.addRecord();
-            const response = await dataUnit.saveData();
-            expect(response).toBeUndefined();
-        });
-
-        it('should handle error SilentException saveLoader', async () => {
-            const saveLoaderMock = jest.fn().mockRejectedValue(new SilentException("Silent", "Test silent"));
-            dataUnit.saveLoader = saveLoaderMock;
-            await dataUnit.addRecord();
-            const saveData = () => dataUnit.saveData();
-            await expect(saveData).rejects.toBeInstanceOf(SilentException);
-        });
-
-        it('should dispatch action on child dataUnits', async () => {
-            const dataUnitChild = dataUnit.getChildDataunit('test');
-            dataUnitChild.addRecord();
-            const savingData = jest.fn();
-            const observer = (action: DataUnitAction) => {
-                if (action.type === Action.SAVING_DATA) {
-                    savingData();
-                }
-            }
-            dataUnitChild.subscribe(observer);
-            await dataUnit.addRecord();
-            dataUnit.saveData();
-            expect(savingData).toHaveBeenCalled();
-        });
-    });
-
-    describe('buildChangesToSaveFromChild', () => {
-        it('should return changes on dataUnit childs', async () => {
-            const parentDataUnit = new DataUnit();
-            const childDataUnit = parentDataUnit.getChildDataunit('test');
-            const changes: Change[] = [];
-            childDataUnit.addRecord();
-            await childDataUnit.setFieldValue('column_name_1', 'new_value');
-            parentDataUnit.buildChangesToSaveFromChild(changes, parentDataUnit);
-            expect(changes).toStrictEqual(
-                expect.arrayContaining([
-                    expect.objectContaining({
-                        record: { "__record__id__": "NEW_0" },
-                        updatingFields: { "column_name_1": "new_value" },
-                    })
-                ])
-            );
-        });
-
-        it('should return empty when no has any change', async () => {
-            const parentDataUnit = new DataUnit();
-            parentDataUnit.getChildDataunit('test');
-            const changes: Change[] = [];
-            parentDataUnit.buildChangesToSaveFromChild(changes, parentDataUnit);
-            expect(changes).toStrictEqual([]);
-        });
-    });
-});

package/test/dataunit/SelectionInfo.spec.ts

@@ -1,143 +0,0 @@
-import { SelectionInfo } from "../../src/dataunit/SelectionInfo";
-import { Record, SelectionMode } from "../../src/dataunit/interfaces/dataUnit";
-import { DataType } from "../../src/dataunit/metadata/DataType";
-import { Filter, Sort, SortMode } from "../../src/dataunit/metadata/UnitMetadata";
-import { recordsTest } from "./resources/records";
-
-describe('SelectionInfo', () => {
-    let selectionInfo: SelectionInfo;
-    const filter: Filter = {
-        name: 'test_filter',
-        expression: 'test',
-    };
-    const sort: Sort = {
-        field: 'column_name_1',
-        dataType: DataType.TEXT,
-        mode: SortMode.DESC,
-    };
-    beforeEach(() => {
-        selectionInfo = new SelectionInfo(
-            recordsTest,
-            SelectionMode.SOME_RECORDS,
-            5,
-            [filter],
-            [sort]
-        );
-    });
-
-    it('should return false when mode is some records', () => {
-        const response = selectionInfo.isAllRecords();
-        expect(response).toBeFalsy();
-    });
-
-    it('should return true when mode is all records', () => {
-        selectionInfo = new SelectionInfo(
-            recordsTest,
-            SelectionMode.ALL_RECORDS,
-            5,
-            [filter],
-            [sort]
-        );
-        const response = selectionInfo.isAllRecords();
-        expect(response).toBeTruthy();
-    });
-
-    it('should return false when records is not empty', () => {
-        const response = selectionInfo.isEmpty();
-        expect(response).toBeFalsy();
-    });
-
-    it('should return true when records is empty', () => {
-        selectionInfo = new SelectionInfo(
-            [],
-            SelectionMode.ALL_RECORDS,
-            5,
-            [filter],
-            [sort]
-        );
-        const response = selectionInfo.isAllRecords();
-        expect(response).toBeTruthy();
-    });
-
-    it('should return number of total when records is empty', () => {
-        selectionInfo = new SelectionInfo(
-            [],
-            SelectionMode.ALL_RECORDS,
-            10,
-            [filter],
-            [sort]
-        );
-        const response = selectionInfo.length;
-        expect(response).toBe(10);
-    });
-
-    it('should return 0 when records is empty and total is undefined ', () => {
-        selectionInfo = new SelectionInfo(
-            [],
-            SelectionMode.ALL_RECORDS,
-            undefined,
-            [filter],
-            [sort]
-        );
-        const response = selectionInfo.length;
-        expect(response).toBe(0);
-    });
-
-    it('should return number of length of records when is not empty', () => {
-        const response = selectionInfo.length;
-        expect(response).toBe(5);
-    });
-
-    it('should return 0 when records is undefined and total is undefined', () => {
-        selectionInfo = new SelectionInfo(
-            undefined as unknown as Array<Record>,
-            SelectionMode.SOME_RECORDS,
-            undefined,
-            [filter],
-            [sort]
-        );
-        const response = selectionInfo.length;
-        expect(response).toBe(0);
-    });
-
-    it('should return undefined when records is undefined', () => {
-        selectionInfo = new SelectionInfo(
-            undefined as unknown as Array<Record>,
-            SelectionMode.SOME_RECORDS,
-            undefined,
-            [filter],
-            [sort]
-        );
-        const response = selectionInfo.recordIds;
-        expect(response).toBeUndefined();
-    });
-
-    it('should call getAllRecords', () => {
-        selectionInfo = new SelectionInfo(
-            [],
-            SelectionMode.ALL_RECORDS,
-            undefined,
-            [filter],
-            [sort]
-        );
-        selectionInfo.getAllRecords = jest.fn();
-        const response = selectionInfo.records;
-        expect(response).toBeUndefined();
-        expect(selectionInfo.getAllRecords).toHaveBeenCalled();
-    });
-
-    it('should handle when getAllRecords is undefined', () => {
-        selectionInfo = new SelectionInfo(
-            [],
-            SelectionMode.ALL_RECORDS,
-            undefined,
-            [filter],
-            [sort]
-        );
-        try {
-            selectionInfo.records;
-        } catch (error) {
-            expect(error).toBeInstanceOf(Error);
-        }
-    });
-});