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

package/test/dataunit/FieldManager.spec.ts

@@ -0,0 +1,286 @@
+import DataUnit from "../../src/dataunit/DataUnit";
+import { DUActionInterceptor } from "../../src/dataunit/interfaces/dataUnit";
+import { DataType } from "../../src/dataunit/metadata/DataType";
+import { FieldDescriptor } from "../../src/dataunit/metadata/UnitMetadata";
+import { Action } from "../../src/dataunit/state/action/DataUnitAction";
+import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
+
+describe('Field manager', () => {
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
+        ({ dataUnit } = createDataUnitMock());
+    });
+
+    describe('setFieldValue', () => {
+        beforeEach(async () => {
+            await dataUnit.loadData();
+        });
+
+        it('should not create a new record when suppressCreateNewRecord is true', async () => {
+            await dataUnit.setFieldValue('column_name_1', 'new_value_1', undefined, { suppressCreateNewRecord: true });
+            const hasNewRecord = dataUnit.hasNewRecord();
+            expect(hasNewRecord).toBeFalsy();
+        });
+
+        it('should resolve promise with false when value is the same', async () => {
+            dataUnit.selectFirst();
+            const response = await dataUnit.setFieldValue('column_name_1', 'column_value_1');
+            expect(response).toBeFalsy();
+        });
+
+        it('should handle with promise values', async () => {
+            const dataChanged = jest.fn();
+            const interceptors: DUActionInterceptor = {
+                interceptAction: (action) => {
+                    if (action.type === Action.DATA_CHANGED) {
+                        dataChanged();
+                    }
+                    return action;
+                }
+            }
+            dataUnit.addInterceptor(interceptors);
+            dataUnit.selectFirst();
+            const promiseValue = new Promise((resolve) => resolve('promise_value'));
+            const response = await dataUnit.setFieldValue('column_name_1', promiseValue);
+
+            expect(response).toBeTruthy();
+            expect(dataChanged).toHaveBeenCalled();
+        });
+
+        it('should return false when value is the same', async () => {
+            dataUnit["areEquivalentValues"] = () => false;
+            dataUnit.selectFirst();
+            const response = await dataUnit.setFieldValue('column_name_1', 'column_value_1');
+            expect(response).toBeFalsy();
+        });
+    });
+
+    describe('disableField', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should set readOnly to true', async () => {
+            dataUnit.disableField('column_name_1');
+            const field = dataUnit.getField('column_name_1');
+            expect(field?.readOnly).toBeTruthy();
+        });
+
+        it('should set readOnly to true when readonly is undefined', async () => {
+            dataUnit.disableField('column_name_2');
+            const field = dataUnit.getField('column_name_2');
+            expect(field?.readOnly).toBeTruthy();
+        });
+
+        it('should not set readOnly when field metadata not exist', async () => {
+            dataUnit.disableField('column_none');
+            const field = dataUnit.getField('column_none');
+            expect(field).toBeUndefined();
+        });
+    });
+
+    describe('enableField', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should set readOnly to false', async () => {
+            dataUnit.enableField('column_name_1');
+            const field = dataUnit.getField('column_name_1');
+            expect(field?.readOnly).toBeFalsy();
+        });
+
+        it('should set readOnly to false when readonly is undefined', async () => {
+            dataUnit.enableField('column_name_2');
+            const field = dataUnit.getField('column_name_2');
+            expect(field?.readOnly).toBeFalsy();
+        });
+
+        it('should not set readOnly when field metadata not exist', async () => {
+            dataUnit.enableField('column_none');
+            const field = dataUnit.getField('column_none');
+            expect(field).toBeUndefined();
+        });
+    });
+
+    describe('hideField', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should set visible to false', async () => {
+            dataUnit.hideField('column_name_1', { visibleOnConfig: true });
+            const field = dataUnit.getField('column_name_1');
+            expect(field?.visible).toBeFalsy();
+            expect(field?.properties?.visibleOnConfig).toBeTruthy();
+        });
+
+        it('should set visible to false when visible is undefined', async () => {
+            dataUnit.hideField('column_name_2', { visibleOnConfig: true });
+            const field = dataUnit.getField('column_name_2');
+            expect(field?.visible).toBeFalsy();
+        });
+
+        it('should handle with options undefined', async () => {
+            dataUnit.hideField('column_name_3', undefined);
+            const field = dataUnit.getField('column_name_3');
+
+            expect(field?.visible).toBeFalsy();
+            expect(field?.properties?.visibleOnConfig).toBeUndefined();
+            expect(field?.properties).toBeUndefined();
+        });
+
+        it('should not set visible when field metadata not exist', async () => {
+            dataUnit.hideField('column_none', { visibleOnConfig: true });
+            const field = dataUnit.getField('column_none');
+            expect(field).toBeUndefined();
+        });
+    });
+
+    describe('showField', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should set visible to true', async () => {
+            dataUnit.showField('column_name_3');
+            const field = dataUnit.getField('column_name_3');
+            expect(field?.visible).toBeTruthy();
+        });
+
+        it('should set visible to true when visible is undefined', async () => {
+            dataUnit.showField('column_name_2');
+            const field = dataUnit.getField('column_name_2');
+            expect(field?.visible).toBeTruthy();
+        });
+
+        it('should not set visible when field metadata not exist', async () => {
+            dataUnit.showField('column_none');
+            const field = dataUnit.getField('column_none');
+            expect(field).toBeUndefined();
+        });
+    });
+
+    describe('addField', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should add field standAlone to metadata', async () => {
+            const field: FieldDescriptor = {
+                name: 'new_field',
+                label: 'New field',
+                dataType: DataType.TEXT,
+            }
+            dataUnit.addField(field);
+            expect(dataUnit.metadata.fields).toStrictEqual(expect.arrayContaining([{ ...field, standAlone: true }]));
+        });
+    });
+
+    describe('valueFromString', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return number type', async () => {
+            const response = dataUnit.valueFromString('column_name_2', '100');
+            expect(response).toEqual(100);
+        });
+
+        it('should return boolean type', async () => {
+            const response = dataUnit.valueFromString('column_name_3', 'true');
+            expect(response).toEqual(true);
+        });
+
+        it('should return value without any format when not has a metadata to field', async () => {
+            const response = dataUnit.valueFromString('column_none', 'true');
+            expect(response).toEqual('true');
+        });
+    });
+
+    describe('valueToString', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return string from the number type', async () => {
+            const response = dataUnit.valueToString('column_name_2', 100);
+            expect(response).toEqual('100');
+        });
+
+        it('should return string from the boolean type', async () => {
+            const response = dataUnit.valueToString('column_name_3', true);
+            expect(response).toEqual('true');
+        });
+
+        it('should return string value when not has a metadata to field', async () => {
+            const response = dataUnit.valueToString('column_none', true);
+            expect(response).toEqual('true');
+        });
+    });
+
+    describe('getFormattedValue', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+            await dataUnit.loadData();
+        });
+
+        it('should return string with number format from the number type', async () => {
+            const response = dataUnit.getFormattedValue('column_name_2', 100);
+            expect(response).toEqual('100,00');
+        });
+
+        it('should return string from the boolean type', async () => {
+            const response = dataUnit.getFormattedValue('column_name_3', true);
+            expect(response).toEqual('Sim');
+        });
+
+        it('should return empty string when value is undefined and not has any record selected', async () => {
+            const response = dataUnit.getFormattedValue('column_name_1');
+            expect(response).toEqual('');
+        });
+
+        it('should return value in string when value is undefined and has a record selected', async () => {
+            dataUnit.selectFirst();
+            const response = dataUnit.getFormattedValue('column_name_1');
+            expect(response).toEqual('column_value_1');
+        });
+
+        it('should return value in string formated when receive a string', async () => {
+            const response = dataUnit.getFormattedValue('column_name_2', '123');
+            expect(response).toEqual('123,00');
+        });
+
+        it('should return value in string with any formated when dont has a metadata field', async () => {
+            const response = dataUnit.getFormattedValue('column_none', '123');
+            expect(response).toEqual('123');
+        });
+
+        it('should return string value when not has a metadata to field', async () => {
+            const response = dataUnit.getFormattedValue('column_none', true);
+            expect(response).toEqual('true');
+        });
+    });
+
+    describe('addSourceFieldValue', () => {
+        beforeEach(async () => {
+            await dataUnit.loadMetadata();
+        });
+
+        it('should return string with number format from the number type', async () => {
+            dataUnit.addSourceFieldValue('column_name_1', 'column_name_2');
+            const response = dataUnit.getSourceFieldValue('column_name_1');
+            expect(response).toEqual('column_name_2');
+        });
+    });
+});

package/test/dataunit/FilterSortsLockersAndObservers.spec.ts

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