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

package/test/dataunit/SavingData.spec.ts

@@ -0,0 +1,206 @@
+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

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

package/test/dataunit/formatting/PrettyFormatter.spec.ts

@@ -18,7 +18,7 @@ describe('getFormattedValue', () => {
   it('should return empty string when value is not an array', () => {
     const value = 'not an array';
     const descriptor = getFileFieldDescriptor();
-    expect(getFormattedValue(value, descriptor)).toBe('');
+    expect(getFormattedValue(value, descriptor)).toBe(value);
   });
 
   it('should return empty string when value is an empty array', () => {

package/test/dataunit/loader/dataUnitInMemoryLoader.spec.ts

@@ -6,7 +6,8 @@ import {
 import { FieldDescriptor, UnitMetadata } from '../../../src/dataunit/metadata/UnitMetadata.js';
 import { DataType } from '../../../src/dataunit/metadata/DataType.js';
 import DateUtils from '../../../src/utils/DateUtils.js';
-import DataUnit, { Record } from '../../../src/dataunit/DataUnit.js';
+import DataUnit from '../../../src/dataunit/DataUnit.js';
+import { Record } from '../../../src/dataunit/interfaces/dataUnit.js';
 
 describe('DataUnitInMemoryLoader - loadData', () => {
   const dataUnitMetetadata: UnitMetadata = {

package/test/dataunit/loader/utils/createDataUnitMock.ts

@@ -0,0 +1,34 @@
+import { DataUnit, LoadDataResponse } from "../../../../src";
+import { metadata } from "../../resources/metadata";
+import { recordsTest } from "../../resources/records";
+
+export function createDataUnitMock(): {
+    dataUnit: DataUnit,
+    dataLoaderMock: jest.Mock,
+    metadataLoaderMock: jest.Mock
+} {
+    const dataUnit = new DataUnit();
+    let dataLoaderMock: jest.Mock;
+    let metadataLoaderMock: jest.Mock;
+    dataLoaderMock = jest.fn((_, request) => {
+        return new Promise<LoadDataResponse>((resolve) => {
+            const { offset = 0, limit = recordsTest.length } = request;
+            const currentPage = Math.floor(offset / limit);
+            const hasMore = (offset + limit) < recordsTest.length;
+            resolve({
+                records: [...recordsTest].slice(offset, offset + limit),
+                paginationInfo: {
+                    currentPage,
+                    hasMore,
+                    firstRecord: offset,
+                    lastRecord: Math.min(offset + limit - 1, recordsTest.length - 1),
+                    count: recordsTest.length
+                },
+            });
+        });
+    });
+    metadataLoaderMock = jest.fn().mockResolvedValue({ ...metadata });
+    dataUnit.dataLoader = dataLoaderMock;
+    dataUnit.metadataLoader = metadataLoaderMock;
+    return { dataUnit, dataLoaderMock, metadataLoaderMock };
+}

package/test/dataunit/loader/utils/dataUnitLoaderUtils.spec.ts

@@ -17,7 +17,7 @@ jest.mock('../../../../src/utils/SortingUtils', () => {
 
 import { DataUnitLoaderUtils } from '../../../../src/dataunit/loader/utils/dataUnitLoaderUtils';
 import { IColumnFilter } from '../../../../src/utils/ColumnFilterManager';
-import { Record } from '../../../../src/dataunit/DataUnit';
+import { Record } from '../../../../src/dataunit/interfaces/dataUnit';
 import { Filter, Sort, SortMode } from '../../../../src/dataunit/metadata/UnitMetadata';
 import { DataType } from '../../../../src/dataunit/metadata/DataType';
 import { ColumnFilterManager } from '../../../../src/utils/ColumnFilterManager';

package/test/dataunit/resources/metadata.ts

@@ -0,0 +1,39 @@
+import { DataType } from "../../../src/dataunit/metadata/DataType";
+import { UnitMetadata } from "../../../src/dataunit/metadata/UnitMetadata";
+
+export const metadata: UnitMetadata = {
+    name: 'test',
+    label: 'test',
+    children: [{
+        name: 'child',
+        label: 'label_child',
+        links: [{ 
+            source: 'source', 
+            target: 'test', 
+        }],
+    }],
+    fields: [
+        {
+            name: 'column_name_1',
+            label: 'Column name 1',
+            dataType: DataType.TEXT,
+            visible: true,
+        },
+        {
+            name: 'column_name_2',
+            label: 'Column name 2',
+            dataType: DataType.NUMBER,
+            readOnly: false,
+            properties: {
+                visibleOnConfig: true,
+            }
+        },
+        {
+            name: 'column_name_3',
+            label: 'Column name 3',
+            dataType: DataType.BOOLEAN,
+            readOnly: true,
+            visible: false,
+        },
+    ],
+}

package/test/dataunit/resources/records.ts

@@ -0,0 +1,29 @@
+import { Record } from "../../../src/dataunit/interfaces/dataUnit";
+
+export const recordsTest: Record[] = [
+    {
+        __record__id__: 'test_1',
+        column_name_1: 'column_value_1',
+        column_name_2: 1,
+    },
+    {
+        __record__id__: 'test_2',
+        column_name_1: 'column_value_1',
+        column_name_2: 2,
+    },
+    {
+        __record__id__: 'test_3',
+        column_name_1: 'column_value_1',
+        column_name_2: 3,
+    },
+    {
+        __record__id__: 'test_4',
+        column_name_1: 'column_value_1',
+        column_name_2: 4,
+    },
+    {
+        __record__id__: 'test_5',
+        column_name_1: 'column_value_1',
+        column_name_2: 5,
+    }
+];

package/test/util/ColumnFilterManager.spec.ts

@@ -1,6 +1,7 @@
 import { ColumnFilterManager, IColumnFilter } from '../../src/utils/ColumnFilterManager.js';
 import { FieldDescriptor, Filter, FilterParam } from '../../src/dataunit/metadata/UnitMetadata.js';
-import DataUnit, { Record } from '../../src/dataunit/DataUnit';
+import DataUnit from '../../src/dataunit/DataUnit';
+import { Record } from '../../src/dataunit/interfaces/dataUnit';
 
 
 describe('ColumnFilterManager', () => {

package/tsconfig.json

@@ -8,6 +8,7 @@
         "strict": true,
         "moduleResolution": "node",
         "declaration": true,
+        "esModuleInterop": true
     },
     "removeComments": true,
     "preserveConstEnums": true,

package/src/dataunit/test/DataUnit.spec.ts

@@ -1,44 +0,0 @@
-import DataUnit  from '../DataUnit';
-import { Action } from '../state/action/DataUnitAction';
-
-describe('DataUnit', () => {
-
-    let dataUnit: DataUnit;
-
-    beforeEach(() => {
-        dataUnit = new DataUnit();
-
-        dataUnit['dispatchAction'] = jest.fn();
-    });
-
-    it('should return false when not waiting to reload', () => {
-        expect(dataUnit.isWaitingToReload()).toBe(false);
-    });
-
-    it('should set waitingToReload to true', () => {
-        dataUnit.setWaitingToReload(true);
-        expect(dataUnit.isWaitingToReload()).toBe(true);
-    });
-
-    it('should set waitingToReload to false', () => {
-        dataUnit.setWaitingToReload(true);
-        dataUnit.setWaitingToReload(false);
-        expect(dataUnit.isWaitingToReload()).toBe(false);
-    });
-
-    it('should dispatch SAVING_CANCELED action with correct fields and recordId', () => {
-        const fields = [
-            { name: 'field1', message: 'error1' },
-            { name: 'field2', message: 'error2' }
-        ];
-        const recordId = '12345';
-
-        dataUnit.savingCanceled(fields, recordId);
-
-        expect(dataUnit['dispatchAction']).toHaveBeenCalledWith(
-            Action.SAVING_CANCELED,
-            { fields, recordId },
-            undefined
-        );
-    });
-});