@zeedhi/common 1.111.1 → 3.0.0

package/tests/unit/components/zd-iterable/column.spec.ts

@@ -0,0 +1,301 @@
+import { Datasource, DatasourceFactory, FormatterParserProvider } from '@zeedhi/core';
+import { Column } from '../../../../src';
+
+jest.useFakeTimers();
+
+describe('Column', () => {
+	afterEach(() => {
+		jest.restoreAllMocks(); // Resets all spied-on methods
+	});
+	
+	describe('constructor()', () => {
+		it('should create new Column with default values', () => {
+			const instance = new Column({ name: 'column' });
+			expect(instance.align).toBe('left');
+			expect(instance.label).toBe('');
+			expect(instance.maxWidth).toBeUndefined();
+			expect(instance.minWidth).toBeUndefined();
+			expect(instance.width).toBeUndefined();
+			expect(instance.mask).toBe('');
+			expect(instance.overflow).toBe('ellipsis');
+			expect(instance.type).toBeUndefined();
+			expect(instance.sortable).toBeTruthy();
+			expect(instance.loading).toBeFalsy();
+			expect(instance.style).toEqual({});
+			expect(instance.actionFixed).toBeFalsy();
+		});
+
+		it('should create new Column replacing default values', () => {
+			const instance = new Column({
+				name: 'column',
+				align: 'center',
+				label: 'label',
+				width: '100%',
+				maxWidth: '500px',
+				minWidth: '100px',
+				mask: '###',
+				overflow: 2,
+				type: 'action',
+				actionFixed: true,
+				sortable: false,
+				loading: true,
+				style: { 'background-color': 'red' },
+			});
+			expect(instance.align).toBe('center');
+			expect(instance.label).toBe('label');
+			expect(instance.width).toBe('100%');
+			expect(instance.maxWidth).toBe('500px');
+			expect(instance.minWidth).toBe('100px');
+			expect(instance.mask).toBe('###');
+			expect(instance.overflow).toBe(2);
+			expect(instance.type).toBe('action');
+			expect(instance.sortable).toBeFalsy();
+			expect(instance.loading).toBeTruthy();
+			expect(instance.actionFixed).toBeTruthy();
+			expect(instance.style).toEqual({ 'background-color': 'red' });
+		});
+	});
+
+	describe('formatter()', () => {
+		it('should return formatted value', () => {
+			const instance = new Column({ name: 'column', mask: '#.#.#' });
+			expect(instance.formatter('123')).toBe('1.2.3');
+			expect(instance.formatter('')).toBe('');
+		});
+
+		it('should return value using registered formatter', () => {
+			FormatterParserProvider.registerFormatter('ZdColumn', (value: string) => value.toUpperCase());
+			const instance = new Column({
+				name: 'column',
+				mask: '#.#.#',
+				componentProps: {
+					name: 'column',
+					component: 'ZdColumn',
+				},
+			});
+			expect(instance.formatter('123')).toBe('123');
+			expect(instance.formatter('abc')).toBe('ABC');
+		});
+	});
+
+	describe('formatterByRow()', () => {
+		it('should return formatted value', () => {
+			const instance = new Column({ name: 'column', mask: '#.#.#' });
+			expect(instance.formatterByRow({ column: '123' })).toBe('1.2.3');
+			expect(instance.formatterByRow({})).toBeUndefined();
+		});
+
+		it('should return value using registered formatter', () => {
+			FormatterParserProvider.registerFormatter('column_ZdColumn', ({ value }: any) => value.toUpperCase());
+			const instance = new Column({
+				name: 'column',
+				mask: '#.#.#',
+				componentProps: {
+					name: 'column',
+					component: 'ZdColumn',
+				},
+			});
+			expect(instance.formatterByRow({ column: '123' })).toBe('123');
+			expect(instance.formatterByRow({ column: 'abc' })).toBe('ABC');
+		});
+	});
+
+	describe('destroy()', () => {
+		it('should destroy the component', () => {
+			const method = jest.fn();
+			const instance = new Column({
+				name: 'column',
+				component: 'Column',
+				events: { onBeforeDestroy: method },
+				componentProps: {
+					name: 'column',
+					component: 'ZdColumn',
+					datasource: {},
+				},
+			});
+			instance.onBeforeDestroy();
+			expect(method).toHaveBeenCalled();
+		});
+
+		it('should destroy the component without lookUpDatasource', () => {
+			const method = jest.fn();
+			const instance = new Column({
+				name: 'column',
+				component: 'Column',
+				events: { onBeforeDestroy: method },
+			});
+			instance.onBeforeDestroy();
+			expect(method).toHaveBeenCalled();
+		});
+	});
+
+	describe('getWidth', () => {
+		it('should get width from view layer', () => {
+			const instance = new Column({ name: 'column' });
+
+			expect(() => instance.getWidth()).toThrow();
+
+			instance.setViewGetWidth(() => 100);
+
+			expect(instance.getWidth()).toBe(100);
+		});
+	});
+
+	describe('getLookupData', () => {
+		it('should not return data', () => {
+			const instance1 = new Column({
+				name: 'code',
+				componentProps: {
+					component: 'ZdSelect',
+					name: 'column',
+					dataText: [{ name: 'id' }, 'name'],
+					formatterDataText: [{ name: 'code' }, 'name'],
+					dataValue: 'id',
+				},
+			});
+			expect(instance1.getLookupData('code', '1')).toBeUndefined();
+			expect(instance1.lookupData).toEqual({ 1: undefined });
+		});
+
+		it('should return data', () => {
+			const spyDatasource = jest
+				.spyOn(Datasource.prototype, 'addFilter')
+				.mockImplementationOnce(async () => Promise.resolve([{ code: '2', name: 'name 2' }]));
+
+			const instance1 = new Column({
+				name: 'code',
+				componentProps: {
+					name: 'column',
+					component: 'ZdColumn',
+					datasource: {
+						data: [{ code: '1', name: 'name 1' }],
+					},
+				},
+			});
+			instance1.initialize();
+
+			expect(instance1.getLookupData('code', '1')).toEqual({ code: '1', name: 'name 1' });
+			expect(instance1.lookupData).toEqual({ 1: { code: '1', name: 'name 1' } });
+			expect(instance1.getLookupData('code', '1')).toEqual({ code: '1', name: 'name 1' });
+			expect(instance1.lookupData).toEqual({ 1: { code: '1', name: 'name 1' } });
+			expect(instance1.getLookupData('teste', '3')).toEqual({});
+			expect(instance1.lookupData).toEqual({ 1: { code: '1', name: 'name 1' }, 3: {} });
+			expect(instance1.getLookupData('code', '2')).toEqual({});
+
+			jest.runAllTimers();
+
+			expect(instance1.lookupData).toEqual({ 1: { code: '1', name: 'name 1' }, 2: {}, 3: {} });
+			spyDatasource.mockClear();
+		});
+	});
+
+	describe('setLookupDataFilter', () => {
+		it('should not call Datasource.setFilter', () => {
+			const spyDatasource = jest.spyOn(Datasource.prototype, 'setFilter');
+
+			const instance = new Column({
+				name: 'code',
+				editable: true,
+				componentProps: {
+					name: 'column',
+					component: 'ZdSelect',
+					dataText: 'text',
+					formatterDataText: 'name',
+					dataValue: 'value',
+					dataValueOut: [{ column: 'text', columnOnGrid: 'name' }],
+				},
+			});
+
+			instance.setLookupDataFilter({ id: 1 });
+
+			expect(spyDatasource).not.toHaveBeenCalled();
+			spyDatasource.mockClear();
+		});
+
+		it('should call Datasource.setFilter', () => {
+			const spyDatasource = jest.spyOn(Datasource.prototype, 'setFilter');
+
+			const instance = new Column({
+				name: 'code',
+				editable: true,
+				componentProps: {
+					name: 'column',
+					component: 'ZdSelect',
+					dataText: 'text',
+					formatterDataText: 'name',
+					dataValue: 'value',
+					dataValueOut: [{ column: 'text', columnOnGrid: 'name' }],
+					datasource: {
+						data: [
+							{ value: 1, text: 'name 1' },
+							{ value: 2, text: 'name 2' },
+						],
+					},
+				},
+			});
+
+			instance.setLookupDataFilter({ id: 1 });
+
+			expect(spyDatasource).toHaveBeenCalled();
+			spyDatasource.mockClear();
+		});
+	});
+
+	describe('clearLookupData', () => {
+		it('when clearLookupData is called should reset datasource.data to its initial value', () => {
+			const col1 = new Column({
+				name: 'col1',
+				componentProps: {
+					name: 'col1',
+					component: 'ZdSelect',
+					datasource: {
+						data: [],
+					},
+				},
+			});
+			col1.componentProps.datasource.data = [1, 2, 3];
+
+			col1.clearLookupData();
+
+			expect(col1.componentProps.datasource.data).toEqual([]);
+		});
+
+		it('when clearLookupData is called and lookupDatasource is undefined, should set empty array', () => {
+			const spy = jest.spyOn(DatasourceFactory, 'factory').mockImplementation(() => undefined);
+			const col1 = new Column({
+				name: 'col1',
+				componentProps: {
+					name: 'col1',
+					component: 'ZdSelect',
+					datasource: {
+						data: [],
+					},
+				},
+			});
+
+			col1.clearLookupData();
+
+			expect(col1.componentProps.datasource.data).toEqual([]);
+			spy.mockClear();
+		});
+	});
+
+	describe('Error', () => {
+		it('when trying to lookup a column that isnt initialized, should throw error', () => {
+			const instance = new Column({
+				name: 'code',
+				componentProps: {
+					name: 'column',
+					component: 'ZdColumn',
+					datasource: {
+						data: [{ code: '1', name: 'name 1' }],
+					},
+				},
+			});
+
+			expect(() => {
+				instance.getLookupData('code', '');
+			}).toThrow();
+		});
+	});
+});

package/tests/unit/components/zd-iterable/conditions-manager.spec.ts

@@ -0,0 +1,123 @@
+import { Event as ZdEvent, IDictionary } from '@zeedhi/core';
+import set from 'lodash.set';
+import { Column } from '../../../../src/components/zd-iterable/column';
+import { ConditionsManager } from '../../../../src/components/zd-iterable/conditions-manager';
+
+jest.mock('lodash.set');
+
+describe('ConditionsManager', () => {
+  let columns: Column[];
+  let mockRow: IDictionary;
+  let manager: ConditionsManager;
+  let visibleFn: jest.Mock;
+  let editableFn: jest.Mock;
+  let childVisibleFn: jest.Mock;
+  let childEditableFn: jest.Mock;
+  let grandchildCssClassFn: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    visibleFn = jest.fn().mockReturnValue(false);
+    editableFn = jest.fn().mockReturnValue(false);
+    childVisibleFn = jest.fn().mockReturnValue(false);
+    childEditableFn = jest.fn().mockReturnValue(true);
+    grandchildCssClassFn = jest.fn().mockReturnValue('class');
+
+    columns = [
+      new Column({ 
+        name: 'col1',
+        conditions: { visible: visibleFn },
+        children: [
+          { name: 'child1', conditions: { visible: childVisibleFn } },
+          { name: 'child2', conditions: { editable: childEditableFn } },
+        ]
+      }),
+      new Column({ name: 'col2', conditions: { editable: editableFn } }),
+      new Column({
+        name: 'col3',
+        children: [
+          {
+            name: 'child3',
+            children: [
+              { name: 'grandchild3', conditions: { cssClass: grandchildCssClassFn } },
+            ],
+          },
+        ],
+      }),
+      new Column({
+        name: 'col4',
+        conditions: {
+          cssStyle: {
+            width: jest.fn().mockReturnValue('200px'),
+          },
+        },
+      }),
+    ];
+
+    mockRow = { id: 1, col1: 'value1', col2: 'value2', child1: 'childValue1', child2: 'childValue2' };
+    manager = new ConditionsManager('id', columns);
+  });
+
+  test('should apply conditions to a row for parent column', () => {
+    const result = manager.applyCondition(mockRow, columns[0]);
+    expect(result).toBeDefined();
+    expect(set).toHaveBeenCalled();
+  });
+
+  test('should apply conditions to child columns', () => {
+    // Reapply conditions to ensure they are set up
+    manager.reapplyConditions(mockRow, columns);
+  
+    // Retrieve applied conditions for child columns using public method
+    const childConditions1 = manager.getAppliedConditions({ row: mockRow, column: columns[0], path: 'child1' });
+    const childConditions2 = manager.getAppliedConditions({ row: mockRow, column: columns[0], path: 'child2' });
+    const grandchildConditions3 = manager.getAppliedConditions({ row: mockRow, column: columns[2], path: 'child3.grandchild3' });
+  
+    expect(childConditions1).toBeDefined();
+    expect(childConditions2).toBeDefined();
+    expect(grandchildConditions3).toBeDefined();
+
+    expect(set).toHaveBeenCalledWith({}, 'visible', false);
+    expect(set).toHaveBeenCalledWith({}, 'editable', false);
+    expect(set).toHaveBeenCalledWith({}, 'cssClass', 'class');
+  });
+
+
+  test
+  test('should return applied conditions for parent column', () => {
+    manager.reapplyConditions(mockRow, columns);
+    const conditions = manager.getAppliedConditions({ row: mockRow, column: columns[0] });
+
+    expect(conditions).toBeDefined();
+  });
+
+  test('should apply conditions for object properties', () => {
+    manager.reapplyConditions(mockRow, columns);
+
+    expect(set).toHaveBeenCalledWith({}, 'cssStyle.width', '200px');
+  });
+
+  test('should not apply conditions for non-functional conditions', () => {
+    jest.spyOn(ZdEvent, 'factory').mockReturnValue({ cssClass: 'true' })
+    const cols = [
+      new Column({
+        name: 'col5',
+        conditions: {
+          cssClass: '{{Controller.cssClass}}',
+        },
+      }),
+    ];
+    const nonFunctionalManager = new ConditionsManager('id', cols);
+    nonFunctionalManager.reapplyConditions(mockRow, cols);
+
+    expect(set).toHaveBeenCalledWith({}, 'cssClass', 'true');
+  });
+
+  test('should not throw when applying conditions for a column that wasnt factored', () => {
+    const nonFactoredManager = new ConditionsManager('id', []);
+
+    const fn = () => nonFactoredManager.reapplyConditions(mockRow, columns);
+
+    expect(fn).not.toThrow();
+  });
+});

package/tests/unit/components/zd-iterable/iterable-columns-button-controller.spec.ts

@@ -0,0 +1,54 @@
+import { IEventParam } from '@zeedhi/core';
+import { Checkbox, Column, Grid, IterableColumnsButtonController } from '../../../../src';
+
+describe('IterableColumnsButtonController', () => {
+  let mockIterable: jest.Mocked<Grid>;
+  let mockColumn: jest.Mocked<Column>;
+  let mockCheckbox: jest.Mocked<Checkbox>;
+  let mockEvent: Event;
+  let mockElement: HTMLElement;
+
+  beforeEach(() => {
+    // Create mock instances
+    mockIterable = { changeLayout: jest.fn() } as any as jest.Mocked<Grid>;
+    mockColumn = new Column({ name: 'testColumn' }) as jest.Mocked<Column>;
+    mockCheckbox = new Checkbox({ name: 'testCheckbox', component: 'ZdCheckbox' }) as jest.Mocked<Checkbox>;
+    mockEvent = new Event('click');
+    mockElement = document.createElement('div');
+
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with the provided iterable component', () => {
+      const controller = new IterableColumnsButtonController(mockIterable);
+      expect(controller['iterableComponent']).toBe(mockIterable);
+    });
+  });
+
+  describe('showHideColumn', () => {
+    it('should update column visibility and call changeLayout', () => {
+      const controller = new IterableColumnsButtonController(mockIterable);
+      const mockValue = true;
+      
+      // Set checkbox value
+      mockCheckbox.value = mockValue;
+
+      // Create mock event param
+      const eventParam: IEventParam<Checkbox> = {
+        component: mockCheckbox,
+        event: mockEvent,
+        element: mockElement
+      };
+
+      controller.showHideColumn(mockColumn, eventParam);
+
+      // Verify column visibility was updated
+      expect(mockColumn.isVisible).toBe(mockValue);
+
+      // Verify changeLayout was called
+      expect(mockIterable.changeLayout).toHaveBeenCalledWith(mockEvent, mockElement);
+    });
+  });
+});

package/tests/unit/components/zd-iterable/iterable-columns-button.spec.ts

@@ -0,0 +1,134 @@
+import { Button, Column, Grid, IterableColumnsButton, Iterable } from '../../../../src';
+import { Loader, Metadata, SimpleControllerBuilder } from '@zeedhi/core';
+
+describe('IterableColumnsButton', () => {
+  const mockProps = {
+    name: 'testButton',
+    component: 'IterableColumnsButton',
+    iterableComponentName: 'testIterable',
+    iconName: 'mdi-test-icon',
+    icon: false,
+    ignoreColumns: ['ignore1', 'ignore2']
+  };
+  let mockColumns = [] as Column[];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockColumns = [
+      { name: 'col1' },
+      { name: 'col2' },
+      { name: 'col3' }
+    ] as Column[];
+
+    jest.spyOn(Metadata, 'getInstances').mockImplementation(() => {
+      return [{
+        columns: mockColumns
+      }]
+    });
+
+    jest.spyOn(Metadata, 'getInstance').mockImplementation(() => {
+      return {
+        columns: mockColumns
+      }
+    });
+  });
+
+  beforeAll(() => {
+    Loader.setBuilder(new SimpleControllerBuilder());
+  });
+
+  describe('constructor', () => {
+    it('should initialize with provided props', () => {
+      const button = new IterableColumnsButton(mockProps);
+      expect(button.iterableComponentName).toBe(mockProps.iterableComponentName);
+      expect(button.iconName).toBe(mockProps.iconName);
+      expect(button.icon).toBe(mockProps.icon);
+      expect(button.ignoreColumns).toEqual(mockProps.ignoreColumns);
+    });
+
+    it('should set the iterableComponent during initialization', () => {
+      const instance = new IterableColumnsButton(mockProps);
+      expect(instance.iterableComponent).toBeDefined(); 
+    });
+  });
+
+  describe('setIterableComponent', () => {
+    it('should set iterableComponent from Metadata when iterableComponentName exists', () => {
+      const mockIterable = {} as Iterable<Column>;
+      (Metadata.getInstances as jest.Mock).mockReturnValue([mockIterable]);
+      (Metadata.getInstance as jest.Mock).mockReturnValue(mockIterable);
+
+      const button = new IterableColumnsButton({
+        ...mockProps,
+        iterableComponentName: 'existingComponent'
+      });
+
+      expect(button.iterableComponent).toBe(mockIterable);
+      expect(Metadata.getInstances).toHaveBeenCalledWith('existingComponent');
+      expect(Metadata.getInstance).toHaveBeenCalledWith('existingComponent');
+    });
+
+    it('should set iterableComponent from parent when parent is Iterable', () => {
+      const mockParent = new Grid({ name: 'parentIterable', component: 'Grid' });
+      const button = new IterableColumnsButton({ name: 'test', component: 'IterableColumnsButton', parent: mockParent });
+
+      expect(button.iterableComponent).toBe(mockParent);
+    });
+
+    it('should throw error when no iterable component can be found', () => {
+      (Metadata.getInstances as jest.Mock).mockReturnValue([]);
+
+      expect(() => new IterableColumnsButton({ name: 'test', component: 'IterableColumnsButton' })).toThrow(
+        'Could not find the iterable component associated with test'
+      );
+    });
+  });
+
+  describe('onCreated', () => {
+    it('should call super.onCreated', () => {
+      const spy = jest.spyOn(Button.prototype, 'onCreated');
+      const button = new IterableColumnsButton(mockProps);
+      button.onCreated();
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it('should register controller with Loader', () => {
+      const button = new IterableColumnsButton(mockProps);
+      button.onCreated();
+
+      expect(button.controller).toBeDefined();
+    });
+  });
+
+  describe('filteredColumns', () => {
+    it('should return columns not in ignoreColumns list', () => {
+      mockColumns = [
+        { name: 'col1' },
+        { name: 'col2' },
+        { name: 'ignore1' },
+        { name: 'col3' },
+        { name: 'ignore2' }
+      ] as Column[];
+
+      const button = new IterableColumnsButton({
+        ...mockProps,
+        ignoreColumns: ['ignore1', 'ignore2']
+      });
+
+      const result = button.filteredColumns();
+      expect(result).toEqual([{ name: 'col1' }, { name: 'col2' }, { name: 'col3' }]);
+    });
+
+    it('should return all columns when ignoreColumns is empty', () => {
+
+      const button = new IterableColumnsButton({
+        ...mockProps,
+        ignoreColumns: []
+      });
+
+      const result = button.filteredColumns();
+      expect(result).toEqual(mockColumns);
+    });
+  });
+});

package/tests/unit/components/zd-iterable/iterable-page-component.spec.ts

@@ -0,0 +1,92 @@
+import { Metadata } from '@zeedhi/core';
+import { IterablePageComponent, Grid } from '../../../../src';
+
+describe('IterablePageComponent', () => {
+  describe('constructor()', () => {
+    it('should create new iterable page component with default values', () => {
+      const iterable = new Grid({
+        name: 'iterable',
+        component: 'ZdIterable',
+      });
+      const instance = new IterablePageComponent({
+        name: 'iterable-page-component',
+        component: 'ZdIterablePageComponent',
+        parent: iterable,
+      });
+      expect(instance.name).toBe('iterable-page-component');
+      expect(instance.component).toBe('ZdIterablePageComponent');
+      expect(instance.parent).toEqual(iterable);
+      expect(instance.iterableComponent).toEqual(iterable);
+      expect(instance.iterableComponentName).toBeUndefined();
+    });
+
+    it('should create new iterable pagination replacing default values', () => {
+      const iterable = new Grid({
+        name: 'iterable',
+        component: 'ZdIterable',
+      });
+      const iterable2 = new Grid({
+        name: 'iterable-2',
+        component: 'ZdIterable',
+      });
+
+      const spy = jest.spyOn(Metadata, 'getInstance').mockImplementation(() => iterable2);
+
+      const instance = new IterablePageComponent({
+        name: 'iterable-page-component',
+        component: 'ZdIterablePageComponent',
+        parent: iterable,
+        iterableComponentName: 'iterable-2',
+      });
+      expect(instance.name).toBe('iterable-page-component');
+      expect(instance.component).toBe('ZdIterablePageComponent');
+      expect(instance.parent).toEqual(iterable);
+      expect(instance.iterableComponent).toEqual(iterable2);
+      expect(instance.iterableComponentName).toBe('iterable-2');
+      spy.mockClear();
+    });
+
+    it('should throw error if parent and iterableComponentName are undefined', () => {
+      let instance;
+
+      const fn = () => {
+        instance = new IterablePageComponent({
+          name: 'iterable-page-component',
+          component: 'ZdIterablePageComponent',
+        });
+      };
+      expect(fn).toThrow('Could not find the iterable component associated with iterable-page-component');
+      expect(instance).toBeUndefined();
+    });
+  });
+
+  describe('onMounted()', () => {
+    it('should set iterableComponent using parent or iterableComponentName', () => {
+      const iterable1 = new Grid({
+        name: 'iterable-1',
+        component: 'ZdIterable',
+      });
+      const iterable2 = new Grid({
+        name: 'iterable-2',
+        component: 'ZdIterable',
+      });
+
+      const spy = jest.spyOn(Metadata, 'getInstance').mockImplementation(() => iterable2);
+
+      const instance = new IterablePageComponent({
+        name: 'iterable-page-component',
+        component: 'ZdIterablePageComponent',
+        parent: iterable1,
+      });
+      expect(instance.parent).toEqual(iterable1);
+      expect(instance.iterableComponent).toEqual(iterable1);
+      instance.onMounted({});
+      expect(instance.iterableComponent).toEqual(iterable1);
+      instance.iterableComponentName = 'iterable-2';
+      instance.onMounted({});
+      expect(instance.iterableComponent).toEqual(iterable2);
+
+      spy.mockClear();
+    });
+  });
+});