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

package/test/dataunit/FilterSortsLockersAndObservers.spec.ts

@@ -1,339 +0,0 @@
-import { randomUUID } from "crypto";
-import DataUnit from "../../src/dataunit/DataUnit";
-import { DUActionInterceptor } from "../../src/dataunit/interfaces/dataUnit";
-import { DataType } from "../../src/dataunit/metadata/DataType";
-import { Filter, FilterProvider, Sort, SortingProvider, SortMode } from "../../src/dataunit/metadata/UnitMetadata";
-import { Action } from "../../src/dataunit/state/action/DataUnitAction";
-import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
-
-describe('Filters, sorts, lockers and observers', () => {
-    let dataUnit: DataUnit;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
-        ({ dataUnit } = createDataUnitMock());
-    });
-
-    describe('release', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should clean dataUnit storage', async () => {
-            const releaseCallbacks = jest.spyOn(dataUnit, 'releaseCallbacks');
-            dataUnit.release();
-            expect(releaseCallbacks).toHaveBeenCalled();
-        });
-
-        it('should unsubscribe parent and remove child', async () => {
-            const childDataUnit = new DataUnit('test', dataUnit);
-            const unsubscribe = jest.spyOn(dataUnit, 'unsubscribe');
-            const removeChildDataunit = jest.spyOn(dataUnit, 'removeChildDataunit');
-            childDataUnit.release();
-            expect(unsubscribe).toHaveBeenCalled();
-            expect(removeChildDataunit).toHaveBeenCalled();
-        });
-    });
-
-    describe('releaseCallbacks', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should clean observers, interceptors, sorting and filters provider', async () => {
-            const interceptorFn = jest.fn();
-            const interceptors: DUActionInterceptor = {
-                interceptAction: (action) => {
-                    interceptorFn();
-                    return action;
-                }
-            }
-            dataUnit.addInterceptor(interceptors);
-
-            const sortingFn = jest.fn();
-            const sortingProvider: SortingProvider = {
-                getSort: () => {
-                    sortingFn();
-                    const sort: Sort = {
-                        field: 'column_name_1',
-                        dataType: DataType.TEXT,
-                        mode: SortMode.DESC,
-                    };
-                    return [sort];
-                },
-            }
-            dataUnit.sortingProvider = sortingProvider;
-
-            const filterFn = jest.fn();
-            const FilterProvider: FilterProvider = {
-                getFilter: () => {
-                    filterFn();
-                    const filter: Filter = {
-                        name: 'test_filter',
-                        expression: 'test',
-                    }
-                    return [filter];
-                }
-            }
-            dataUnit.addFilterProvider(FilterProvider);
-
-            const observerFn = jest.fn();
-            const observer = async () => {
-                observerFn();
-                return;
-            }
-
-            dataUnit.subscribe(observer);
-
-            dataUnit.releaseCallbacks();
-
-            await dataUnit.loadData();
-            dataUnit.getSort();
-            dataUnit.selectFirst();
-
-            expect(interceptorFn).not.toHaveBeenCalled();
-            expect(sortingFn).not.toHaveBeenCalled();
-            expect(filterFn).not.toHaveBeenCalled();
-            expect(observerFn).not.toHaveBeenCalled();
-        });
-
-        it('should not clean observers when allowReleaseCallbacks is false', async () => {
-            dataUnit.allowReleaseCallbacks = false;
-            const observerFn = jest.fn();
-            const observer = async () => {
-                observerFn();
-                return;
-            }
-            dataUnit.subscribe(observer);
-
-            dataUnit.releaseCallbacks();
-            await dataUnit.loadData();
-
-            expect(observerFn).toHaveBeenCalled();
-        });
-    });
-
-    describe('addInterceptor', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should remove interceptors', async () => {
-            const dataLoadedFn = jest.fn();
-            const interceptors: DUActionInterceptor = {
-                interceptAction: (action) => {
-                    if (action.type === Action.DATA_LOADED) {
-                        dataLoadedFn();
-                    }
-                    return action;
-                }
-            }
-            dataUnit.addInterceptor(interceptors);
-            await dataUnit.loadData();
-            expect(dataLoadedFn).toHaveBeenCalled();
-            dataUnit.removeInterceptor(interceptors);
-            dataLoadedFn.mockClear();
-            await dataUnit.loadData();
-            expect(dataLoadedFn).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('addFilterProvider', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should remove filterProvider', async () => {
-            const filterFn = jest.fn();
-            const filterProvider: FilterProvider = {
-                getFilter: () => {
-                    filterFn();
-                    const filter: Filter = {
-                        name: 'test_filter',
-                        expression: 'test',
-                    }
-                    return [filter];
-                }
-            }
-            dataUnit.addFilterProvider(filterProvider);
-            await dataUnit.loadData();
-            expect(filterFn).toHaveBeenCalled();
-            dataUnit.removeFilterProvider(filterProvider);
-            filterFn.mockClear();
-            await dataUnit.loadData();
-            expect(filterFn).not.toHaveBeenCalled();
-        });
-
-        it('should add filterProvider with custom key', async () => {
-            const filterFn = jest.fn();
-            const filter: Filter = {
-                name: 'test_filter',
-                expression: 'test',
-            }
-            const filterProvider: FilterProvider = {
-                getFilter: () => {
-                    filterFn();
-                    return [filter];
-                },
-                getKey: () => 'customKey',
-            }
-            dataUnit.addFilterProvider(filterProvider);
-            await dataUnit.loadData();
-            expect(filterFn).toHaveBeenCalled();
-            const response = dataUnit.getFilters();
-            expect(response).toStrictEqual([filter]);
-        });
-    });
-
-    describe('subscribe', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should remove observer', async () => {
-            const observerFn = jest.fn();
-            const observer = async () => {
-                observerFn();
-                return;
-            }
-            dataUnit.subscribe(observer);
-            await dataUnit.loadData();
-            expect(observerFn).toHaveBeenCalled();
-            dataUnit.unsubscribe(observer);
-            observerFn.mockClear();
-            await dataUnit.loadData();
-            expect(observerFn).not.toHaveBeenCalled();
-        });
-
-        it('should set observer with uuid', async () => {
-            const uuid = randomUUID();
-            const observerFn = jest.fn();
-            const observer = async () => {
-                observerFn();
-                return;
-            }
-            dataUnit.subscribe(observer, uuid);
-            await dataUnit.loadData();
-            expect(observerFn).toHaveBeenCalled();
-            dataUnit.unsubscribe(observer, uuid);
-            observerFn.mockClear();
-            await dataUnit.loadData();
-            expect(observerFn).not.toHaveBeenCalled();
-        });
-
-        it('should set observer with error', async () => {
-            const observerFn = jest.fn();
-            const warn = jest.spyOn(global.console, 'warn');
-            const observer = () => {
-                observerFn();
-                throw new Error('test');
-            }
-            dataUnit.subscribe(observer);
-            await dataUnit.loadData();
-            expect(warn).toHaveBeenCalledWith('[DataUnit] error while call observer', expect.anything());
-        });
-    });
-
-    describe('getAppliedFilters', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should return applied filters', async () => {
-            const filter: Filter = {
-                name: 'test_filter',
-                expression: 'test',
-            }
-            const FilterProvider: FilterProvider = {
-                getFilter: () => {
-                    return [filter];
-                }
-            }
-            dataUnit.addFilterProvider(FilterProvider);
-            await dataUnit.loadData();
-            const response = dataUnit.getAppliedFilters();
-            expect(response).toStrictEqual([filter]);
-        });
-
-        it('should return undefined when filter is not applied', () => {
-            const newDataUnit = new DataUnit();
-            const filter: Filter = {
-                name: 'test_filter',
-                expression: 'test',
-            }
-            const FilterProvider: FilterProvider = {
-                getFilter: () => {
-                    return [filter];
-                }
-            }
-            newDataUnit.addFilterProvider(FilterProvider);
-            const response = newDataUnit.getAppliedFilters();
-            expect(response).toBeUndefined();
-        });
-    });
-
-    describe('addLoadingLocker', () => {
-        const dataLoaded = jest.fn();
-
-        beforeEach(() => {
-            dataLoaded.mockClear();
-            const interceptors: DUActionInterceptor = {
-                interceptAction: (action) => {
-                    if (action.type === Action.DATA_LOADED) {
-                        dataLoaded();
-                    }
-                    return action;
-                }
-            }
-            dataUnit.addInterceptor(interceptors);
-        });
-
-        it('should loaded data just when unlock', async () => {
-            const unlock = dataUnit.addLoadingLocker();
-            const promiseLoadData = dataUnit.loadData();
-            expect(dataLoaded).not.toHaveBeenCalled();
-            unlock();
-            await promiseLoadData;
-            expect(dataLoaded).toHaveBeenCalled();
-        });
-    });
-
-    describe('hasWaitingChanges', () => {
-        beforeEach(async () => {
-            await dataUnit.loadMetadata();
-            await dataUnit.loadData();
-        });
-
-        it('should return status waiting changes', () => {
-            dataUnit.startChange('column_name_1', {
-                blocking: true,
-                waitmessage: 'test',
-            });
-            let hasWaitingChanges = dataUnit.hasWaitingChanges();
-            expect(hasWaitingChanges).toBeTruthy();
-            dataUnit.cancelWaitingChange('column_name_1');
-            hasWaitingChanges = dataUnit.hasWaitingChanges();
-            expect(hasWaitingChanges).toBeFalsy();
-        });
-    });
-
-    describe('addGlobalLoaderProp', () => {
-        it('should set global properties', () => {
-            dataUnit.addGlobalLoaderProp('prop_name', 'prop_value');
-            const properties = dataUnit.getGlobalLoaderProps();
-            expect(properties).toStrictEqual(new Map([['prop_name', 'prop_value']]));
-        });
-
-        it('should return empty map when global properties not set', () => {
-            const properties = dataUnit.getGlobalLoaderProps();
-            expect(properties).toStrictEqual(new Map());
-        });
-    });
-});

package/test/dataunit/InfoManager.spec.ts

@@ -1,254 +0,0 @@
-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?');
-        });
-    });
-});