@zeedhi/common 3.0.4 → 3.0.6

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

@@ -256,7 +256,8 @@ describe('Component', () => {
 		it('should retrieve a child', () => {
 			const parent = new Component({ name: 'parent' });
 			const instance = new Component({ parent, name: 'component' });
-			const spy = jest.spyOn(console, 'warn').mockImplementation(() => true);
+			const spy = jest.spyOn(console, 'warn');
+			spy.mockReset();
 			instance.onCreated();
 			const child = parent.getChildInstance<Component>('component');
 			expect(child.name).toBe('component');
@@ -279,7 +280,7 @@ describe('Component', () => {
 		it('should only add instance to Metadata', () => {
 			const instance = new Component({ name: 'component' });
 			const spy = jest.spyOn(Metadata, 'addInstance');
-			const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => true);
+			const consoleSpy = jest.spyOn(console, 'warn');
 			instance.onCreated();
 			expect(spy).toHaveBeenCalledWith(instance, false);
 			expect(consoleSpy).toHaveBeenCalled();

package/tests/unit/components/zd-date-range/date-range.spec.ts

@@ -352,6 +352,21 @@ describe('DateRange', () => {
       expect(instance.displayValue).toBe('');
     });
 
+    it('should call change event when clearing the value', () => {
+      const changeFn = jest.fn();
+      const instance = new DateRange({
+        name: 'date',
+        component: 'DateRange',
+        events: {
+          change: changeFn,
+        },
+      });
+      instance.setDateValue('01-01-2020 ~ 01-02-2020');
+      changeFn.mockClear();
+      instance.setDateValue('');
+      expect(changeFn).toHaveBeenCalled();
+    });
+
     it('shouldn\'t update displayValue when the value passed is invalid', () => {
       const instance = new DateRange({ name: 'date', component: 'DateRange' });
       instance.setDateValue('01-01-2020 ~ 01-02-2020');
@@ -423,6 +438,40 @@ describe('DateRange', () => {
       expect(instance.isValidDate('07/13/2023', 'MM/DD/YYYY')).toBeFalsy();
       expect(instance.isValidDate('07/01/2023', 'MM/DD/YYYY')).toBeFalsy();
     });
+
+    it('should return false for a completely invalid date format', () => {
+      const instance = new DateRange({ name: 'date', component: 'DateRange' });
+      // This should hit the !isValidFormat check at the beginning of isValidDate
+      expect(instance.isValidDate('not-a-date', 'YYYY-MM-DD')).toBeFalsy();
+    });
+
+    it('should return false for a not allowed date', () => {
+      const instance = new DateRange({
+        name: 'date',
+        component: 'DateRange',
+        dateFormat: 'YYYY-MM-DD',
+        allowedDates: (date: string) => date !== '2023-07-11',
+      });
+
+      // Date is valid, but not allowed
+      expect(instance.isValidDate('2023-07-11', 'YYYY-MM-DD')).toBeFalsy();
+      // Other date should be valid and allowed
+      expect(instance.isValidDate('2023-07-12', 'YYYY-MM-DD')).toBeTruthy();
+    });
+
+    it('should return true for allowed date with array', () => {
+      const instance = new DateRange({
+        name: 'date',
+        component: 'DateRange',
+        dateFormat: 'YYYY-MM-DD',
+        allowedDates: ['2025-01-01'],
+      });
+
+      // Date is valid and allowed
+      expect(instance.isValidDate('2025-01-01', 'YYYY-MM-DD')).toBeTruthy();
+      // Date is valid but not allowed
+      expect(instance.isValidDate('2025-01-02', 'YYYY-MM-DD')).toBeFalsy();
+    });
   });
 
   describe('isoRangeValue', () => {
@@ -654,6 +703,23 @@ describe('DateRange', () => {
     });
   });
 
+  describe('isValidDateArray', () => {
+    it('should return false if values array has less than 2 items', () => {
+      const instance = new DateRange({ name: 'date', component: 'DateRange' });
+      expect(instance.isValidDateArray('YYYY-MM-DD', ['2025-01-01'])).toBe(false);
+    });
+
+    it('should return true if all dates in array are valid', () => {
+      const instance = new DateRange({ name: 'date', component: 'DateRange' });
+      expect(instance.isValidDateArray('YYYY-MM-DD', ['2025-01-01', '2025-01-10'])).toBe(true);
+    });
+
+    it('should return false if any date in array is invalid', () => {
+      const instance = new DateRange({ name: 'date', component: 'DateRange' });
+      expect(instance.isValidDateArray('YYYY-MM-DD', ['2025-01-01', 'invalid-date'])).toBe(false);
+    });
+  });
+
   describe('FormatterParserProvider', () => {
     it('should return formatter function', () => {
       const formatterFn = FormatterParserProvider.getFormatter('ZdDateRange');
@@ -1002,6 +1068,61 @@ describe('DateRange Tests', () => {
       expect(dateInput.value).toEqual(['2025-01-01', '2025-01-05']);
       expect(dateInput.displayValue).toBe('01/01/2025 ~ 05/01/2025');
     });
+
+    it('should handle more than two dates, using extremities', () => {
+      const start = new Date(2025, 0, 1);
+      const middle = new Date(2025, 0, 3);
+      const end = new Date(2025, 0, 5);
+      dateInput.dateFormat = 'YYYY-MM-DD';
+      dateInput.displayFormat = 'DD/MM/YYYY';
+      dateInput.setNativeDate([start, middle, end]);
+
+      expect(dateInput.value).toEqual(['2025-01-01', '2025-01-05']);
+    });
+
+    it('should handle an empty array', () => {
+      dateInput.value = ['2024-12-31'];
+      dateInput.setNativeDate([]);
+      expect(dateInput.value).toEqual([]);
+    });
+
+    it('should handle a single date without an end date', () => {
+      const start = new Date(2025, 0, 1);
+      dateInput.dateFormat = 'YYYY-MM-DD';
+      dateInput.displayFormat = 'DD/MM/YYYY';
+      dateInput.allowedDates = (date) => date === '2025-01-01';
+
+      dateInput.setNativeDate([start]);
+
+      expect(dateInput.value).toEqual(['2025-01-01']);
+    });
+
+    it('should not set date if any date in range is not allowed', () => {
+      const start = new Date(2025, 0, 1);
+      const end = new Date(2025, 0, 5);
+      dateInput.dateFormat = 'YYYY-MM-DD';
+      dateInput.displayFormat = 'DD/MM/YYYY';
+      dateInput.allowedDates = (date) => date !== '2025-01-03';
+
+      dateInput.value = ['2024-12-31'];
+      dateInput.setNativeDate([start, end]);
+
+      // Value should not change
+      expect(dateInput.value).toEqual(['2024-12-31']);
+    });
+
+    it('should handle null or undefined dates to cover fallback', () => {
+      dateInput.value = ['2025-01-01'];
+
+      // Test with null to cover `(dates || [])`
+      dateInput.setNativeDate(null as any);
+      expect(dateInput.value).toEqual([]);
+
+      // Reset and test with undefined
+      dateInput.value = ['2025-01-01'];
+      dateInput.setNativeDate(undefined as any);
+      expect(dateInput.value).toEqual([]);
+    });
   });
 
   describe('getNativeDate', () => {
@@ -1020,6 +1141,40 @@ describe('DateRange Tests', () => {
       expect(nativeDates).toEqual([]);
     });
   });
+
+  describe('getAllowedDates', () => {
+    it('should return true if allowedDates is not set', () => {
+      const instance = new DateRange({ name: 'date', component: 'ZdDateRange' });
+      expect(instance.getAllowedDates(new Date(2025, 0, 1))).toBe(true);
+    });
+
+    it('should return false if allowedDates is an empty array', () => {
+      const instance = new DateRange({ name: 'date', component: 'ZdDateRange', allowedDates: [] });
+      expect(instance.getAllowedDates(new Date(2025, 0, 1))).toBe(false);
+    });
+
+    it('should return true for allowed date with function', () => {
+      const instance = new DateRange({
+        name: 'date',
+        component: 'ZdDateRange',
+        dateFormat: 'YYYY-MM-DD',
+        allowedDates: (date) => date === '2025-01-01',
+      });
+      expect(instance.getAllowedDates(new Date(2025, 0, 1))).toBe(true);
+      expect(instance.getAllowedDates(new Date(2025, 0, 2))).toBe(false);
+    });
+
+    it('should return true for allowed date with array', () => {
+      const instance = new DateRange({
+        name: 'date',
+        component: 'ZdDateRange',
+        dateFormat: 'YYYY-MM-DD',
+        allowedDates: ['2025-01-01'],
+      });
+      expect(instance.getAllowedDates(new Date(2025, 0, 1))).toBe(true);
+      expect(instance.getAllowedDates(new Date(2025, 0, 2))).toBe(false);
+    });
+  });
 });
 
 describe('DateRange edge cases', () => {
@@ -1035,33 +1190,17 @@ describe('DateRange edge cases', () => {
   });
 });
 
-
 dayjs.extend(utc);
 
-describe('DateRange map format line 493 coverage', () => {
-  it('should format dates and handle nulls internally', () => {
-    const dateInput = new DateRange({
-      name: 'date',
-      component: 'DateInput',
-      dateFormat: 'YYYY-MM-DD',
-    });
-
-    const start = new Date(2025, 0, 1); // local 1 Jan 2025
-    const end = new Date(2025, 0, 5);   // local 5 Jan 2025
-
-    dateInput.setNativeDate([start, end]);
-
-    expect(dateInput.value).toEqual([
-      dayjs(start).format('YYYY-MM-DD'),
-      dayjs(end).format('YYYY-MM-DD'),
-    ]);
+describe('DateRange getExtremities coverage', () => {
+  it('should cover empty array case in getExtremities by setting value', () => {
+    const dateInput = new DateRange({ name: 'date', component: 'DateInput' });
+    dateInput.value = ['2025-01-01']; // Define um valor inicial
 
-    // apenas uma data
-    dateInput.setNativeDate([start]);
-    expect(dateInput.value).toEqual([dayjs(start).format('YYYY-MM-DD')]);
+    // Atribuir um array vazio ao 'value' aciona o setter,
+    // que indiretamente causa a chamada de 'getExtremities' com um array vazio.
+    dateInput.value = [];
 
-    // array vazio
-    dateInput.setNativeDate([]);
     expect(dateInput.value).toEqual([]);
   });
 });
@@ -1122,4 +1261,31 @@ describe('DateRange.getNativeDate', () => {
   });
 });
 
+describe('DateRange value setter edge cases', () => {
+  it('should handle null and undefined values correctly', () => {
+    const dateInput = new DateRange({ name: 'date', component: 'DateInput' });
+    dateInput.value = ['2025-01-01'];
+
+    dateInput.value = null;
+    expect(dateInput.value).toEqual([]);
+
+    dateInput.value = undefined;
+    expect(dateInput.value).toEqual([]);
+  });
+});
+
+describe('DateRange getExtremities coverage', () => {
+  it('should cover empty array case in getExtremities by setting value to empty array', () => {
+    const dateInput = new DateRange({ name: 'date', component: 'DateInput' });
+    // Define um valor inicial para garantir que a mudança seja detectada
+    dateInput.value = ['2025-01-01'];
+
+    // Atribui um array vazio diretamente ao 'value'.
+    // Isso aciona o setter que define 'dateObject' como [], cobrindo o caso de borda em 'getExtremities'.
+    dateInput.value = [];
+
+    expect(dateInput.value).toEqual([]);
+  });
+});
+
 });

package/tests/unit/components/zd-grid/grid.spec.ts

@@ -161,23 +161,36 @@ describe('Grid', () => {
       expect(instance.cellSelection).toBeTruthy();
     });
 
-    it('should create new grid with change default slot names', () => {
+    it('on slot creation, should replace <<NAME>> tags by the grid name', () => {
+      const fn = jest.fn();
       const instance = new Grid({
         name: 'Grid',
         component: 'ZdGrid',
         footerSlot: [
-          { name: 'iterablePagination', component: 'ZdIterablePagination' },
-          { name: 'iterablePageSize', component: 'ZdIterablePageSize' },
-          { name: 'iterablePageInfo', component: 'ZdIterablePageInfo' },
+          { name: 'pagination_<<NAME>>', component: 'ZdIterablePagination' },
         ],
-        toolbarSlot: [{ name: 'gridSearch', component: 'ZdSearch' }],
+        toolbarSlot: [{
+          name: 'gridSearch', component: 'ZdSearch', children: [{
+            name: 'deep_<<NAME>>',
+            component: 'ZdInput',
+            nullProp: null,
+            functionProp: fn,
+          }]
+        }],
       });
       expect(instance.footerSlot).toEqual([
-        { name: 'iterablePagination', component: 'ZdIterablePagination' },
-        { name: 'iterablePageSize', component: 'ZdIterablePageSize' },
-        { name: 'iterablePageInfo', component: 'ZdIterablePageInfo' },
+        { name: 'pagination_Grid', component: 'ZdIterablePagination' },
       ]);
-      expect(instance.toolbarSlot).toEqual([{ name: 'gridSearch', component: 'ZdSearch' }]);
+      expect(instance.toolbarSlot).toEqual([{
+        name: 'gridSearch', component: 'ZdSearch', children: [
+          {
+            name: 'deep_Grid',
+            component: 'ZdInput',
+            nullProp: null,
+            functionProp: fn,
+          },
+        ]
+      }]);
     });
 
     it('should not add action columns in datasource searchIn', () => {
@@ -385,7 +398,7 @@ describe('Grid', () => {
           cellClick: ({ column }: any) => { cellClicked = column.name; },
         },
       });
-			instance.onCreated();
+      instance.onCreated();
       const event = new MouseEvent('click');
       const element = document.createElement('div');
       instance.cellClick({ id: 1 }, instance.columns[0] as GridColumn, event, element);
@@ -1474,31 +1487,31 @@ describe('Grid', () => {
 
       expect(grid.getCurrentRowIndex()).toBe(0)
     })
-   })
-
-   describe('getColumn()', () => {
-     it('should return a column', () => {
-       const instance = new Grid({
-         name: 'iterable',
-         component: 'Iterable',
-         columns: [
-           { name: 'column', component: 'Column' },
-         ],
-       });
-       expect(instance.getColumn('column')).toBeInstanceOf(GridColumn);
-     });
- 
-     it('should throw an error if column does not exist', () => {
-       const instance = new Grid({
-         name: 'iterable',
-         component: 'Iterable',
-         columns: [
-           { name: 'column', component: 'Column' },
-         ],
-       });
-       expect(() => { instance.getColumn('column2'); }).toThrow();
-     });
-   });
+  })
+
+  describe('getColumn()', () => {
+    it('should return a column', () => {
+      const instance = new Grid({
+        name: 'iterable',
+        component: 'Iterable',
+        columns: [
+          { name: 'column', component: 'Column' },
+        ],
+      });
+      expect(instance.getColumn('column')).toBeInstanceOf(GridColumn);
+    });
+
+    it('should throw an error if column does not exist', () => {
+      const instance = new Grid({
+        name: 'iterable',
+        component: 'Iterable',
+        columns: [
+          { name: 'column', component: 'Column' },
+        ],
+      });
+      expect(() => { instance.getColumn('column2'); }).toThrow();
+    });
+  });
 
   describe('pageText', () => {
     it('should get paging info', () => {

package/tests/unit/components/zd-grid-editable/data-editor.spec.ts

@@ -192,7 +192,7 @@ describe('DataEditor', () => {
   });
 
   describe('updateRow', () => {
-    const spy = jest.spyOn(console, 'warn').mockImplementation(() => true);
+    const spy = jest.spyOn(console, 'warn');
 
     expect(spy).not.toHaveBeenCalled();
     expect(spy).toHaveBeenCalledTimes(0);

package/tests/unit/components/zd-grid-editable/grid-editable.spec.ts

@@ -813,7 +813,7 @@ describe('Grid Editable', () => {
         },
       );
 
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => true);
+      const consoleSpy = jest.spyOn(console, 'warn');
 
       const formatterFn = FormatterParserProvider.getFormatter('column_ZdSelect');
 

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

@@ -162,8 +162,49 @@ describe('Column', () => {
 				.spyOn(Datasource.prototype, 'addFilter')
 				.mockImplementationOnce(async () => Promise.resolve([{ code: '2', name: 'name 2' }]));
 
+			const spyConsole = jest
+				.spyOn(console, 'warn')
+				.mockImplementationOnce(() => true);
+
+			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();
+			spyConsole.mockClear();
+		});
+
+		it('should return data using storeData', () => {
+			const spyDatasource = jest
+				.spyOn(Datasource.prototype, 'addFilter')
+				.mockImplementationOnce(async () => Promise.resolve([{ code: '2', name: 'name 2' }]));
+
+			const spyConsole = jest
+				.spyOn(console, 'warn')
+				.mockImplementationOnce(() => true);
+
 			const instance1 = new Column({
 				name: 'code',
+				storeData: false,
 				componentProps: {
 					name: 'column',
 					component: 'ZdColumn',
@@ -186,6 +227,7 @@ describe('Column', () => {
 
 			expect(instance1.lookupData).toEqual({ 1: { code: '1', name: 'name 1' }, 2: {}, 3: {} });
 			spyDatasource.mockClear();
+			spyConsole.mockClear();
 		});
 	});
 

package/tests/unit/utils/mock-console.ts

@@ -0,0 +1,18 @@
+const originalWarn = console.warn;
+const originalError = console.error;
+
+beforeAll(() => {
+  jest.spyOn(console, 'warn').mockImplementation((...args) => {
+    // Oculta apenas mensagens específicas
+    if (args.join(' ').includes('Duplicate component name detected')
+     || args.join(' ').includes('Row datasource do not have a key')
+     || args.join(' ').includes('Nenhum datasource foi passado para o componente')) return;
+    return originalWarn(...args);
+  });
+
+  jest.spyOn(console, 'error').mockImplementation((...args) => {
+    // Oculta apenas mensagens específicas
+    if (args.join(' ').includes('Controller ') && args.join(' ').includes(' not found')) return;
+    return originalError(...args);
+  });
+});