@zeedhi/teknisa-components-common 3.0.0 → 3.0.2

package/tests/unit/components/tek-grid/columns-searcher.spec.ts

@@ -0,0 +1,112 @@
+import { ColumnsSearcher, ITekGridColumn } from '../../../../src';
+
+describe("ColumnsSearcher", () => {
+  let columnsSearcher: ColumnsSearcher;
+
+  beforeEach(() => {
+    columnsSearcher = new ColumnsSearcher();
+  });
+
+  describe("searchColumn", () => {
+    it("should return empty object when search string is empty", async () => {
+      const columns: ITekGridColumn[] = [
+        {
+          name: "testColumn",
+          componentProps: { name: 'testColumnName', datasource: { uniqueKey: "id" } },
+          memorySearch: jest.fn(),
+        },
+      ];
+      const search = "";
+
+      const result = await columnsSearcher.searchColumn(columns, search);
+
+      expect(result).toEqual({});
+      expect(columns[0].memorySearch).not.toHaveBeenCalled();
+    });
+
+    it("should skip columns without datasource", async () => {
+      const columns: ITekGridColumn[] = [
+        {
+          name: "noDataSourceColumn",
+          componentProps: { name: 'noDataSourceColumnName' },
+          memorySearch: jest.fn(),
+        },
+        {
+          name: "validColumn",
+          componentProps: { name: 'validColumnName', datasource: { uniqueKey: "id" } },
+          memorySearch: jest.fn().mockResolvedValue([{ id: 1 }]),
+        },
+      ];
+      const search = "test";
+
+      const result = await columnsSearcher.searchColumn(columns, search);
+
+      expect(result).toEqual({ validColumn: [1] });
+      expect(columns[0].memorySearch).not.toHaveBeenCalled();
+      expect(columns[1].memorySearch).toHaveBeenCalledWith("test");
+    });
+
+    it("should skip columns with skipLookupSearch=true", async () => {
+      const columns: ITekGridColumn[] = [
+        {
+          name: "skippedColumn",
+          componentProps: { name: 'skippedColumnName', datasource: { uniqueKey: "id" } },
+          skipLookupSearch: true,
+          memorySearch: jest.fn(),
+        },
+        {
+          name: "validColumn",
+          componentProps: { name: 'validColumnName', datasource: { uniqueKey: "id" } },
+          memorySearch: jest.fn().mockResolvedValue([{ id: 1 }]),
+        },
+      ];
+      const search = "test";
+
+      const result = await columnsSearcher.searchColumn(columns, search);
+
+      expect(result).toEqual({ validColumn: [1] });
+      expect(columns[0].memorySearch).not.toHaveBeenCalled();
+      expect(columns[1].memorySearch).toHaveBeenCalledWith("test");
+    });
+
+    it("should process multiple columns in parallel", async () => {
+      const columns: ITekGridColumn[] = [
+        {
+          name: "column1",
+          componentProps: { name: 'column1Name', datasource: { uniqueKey: "id" } },
+          memorySearch: jest.fn().mockResolvedValue([{ id: 1 }, { id: 2 }]),
+        },
+        {
+          name: "column2",
+          componentProps: { name: 'column2Name', datasource: { uniqueKey: "code" } },
+          memorySearch: jest.fn().mockResolvedValue([{ code: "A" }, { code: "B" }]),
+        },
+      ];
+      const search = "test";
+
+      const result = await columnsSearcher.searchColumn(columns, search);
+
+      expect(result).toEqual({
+        column1: [1, 2],
+        column2: ["A", "B"],
+      });
+      expect(columns[0].memorySearch).toHaveBeenCalledWith("test");
+      expect(columns[1].memorySearch).toHaveBeenCalledWith("test");
+    });
+
+    it("should handle empty search results", async () => {
+      const columns: ITekGridColumn[] = [
+        {
+          name: "emptyResultsColumn",
+          componentProps: { name: 'emptyResultsColumnName', datasource: { uniqueKey: "id" } },
+          memorySearch: jest.fn().mockResolvedValue([]),
+        },
+      ];
+      const search = "test";
+
+      const result = await columnsSearcher.searchColumn(columns, search);
+
+      expect(result).toEqual({ emptyResultsColumn: [] });
+    });
+  });
+});

package/tests/unit/components/tek-grid/dynamic-filter-datasource-factory.spec.ts

@@ -0,0 +1,90 @@
+import { Datasource, DatasourceFactory, IDictionary } from '@zeedhi/core';
+import { DynamicFilterDatasourceFactory } from '../../../../src';
+
+describe('DynamicFilterDatasourceFactory', () => {
+  let factory: DynamicFilterDatasourceFactory;
+  let mockDatasourceFactory: jest.Mocked<typeof DatasourceFactory>;
+
+  beforeEach(() => {
+    factory = new DynamicFilterDatasourceFactory();
+    
+    // Create a mock for just the DatasourceFactory.factory method
+    mockDatasourceFactory = {
+      factory: jest.fn(),
+    } as unknown as jest.Mocked<typeof DatasourceFactory>;
+    
+    // Replace the original implementation with our mock
+    jest.spyOn(DatasourceFactory, 'factory').mockImplementation(mockDatasourceFactory.factory);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('factory', () => {
+    it('should create a datasource with correct configuration', () => {
+      const mockOptions: IDictionary<boolean> = {
+        option1: true,
+        option2: false,
+      };
+      const expectedData = [
+        { text: 'TEKGRID_option1', value: 'option1' },
+        { text: 'TEKGRID_option2', value: 'option2' },
+      ];
+      const mockDatasource = {} as Datasource;
+      
+      mockDatasourceFactory.factory.mockReturnValue(mockDatasource);
+
+      const result = factory.factory(mockOptions);
+
+      expect(mockDatasourceFactory.factory).toHaveBeenCalledWith({
+        data: expectedData,
+        loadAll: true,
+        translate: ['text'],
+      });
+      expect(result).toBe(mockDatasource);
+    });
+
+    it('should handle empty options', () => {
+      const mockOptions: IDictionary<boolean> = {};
+      const mockDatasource = {} as Datasource;
+      
+      mockDatasourceFactory.factory.mockReturnValue(mockDatasource);
+
+      const result = factory.factory(mockOptions);
+
+      expect(mockDatasourceFactory.factory).toHaveBeenCalledWith({
+        data: [],
+        loadAll: true,
+        translate: ['text'],
+      });
+      expect(result).toBe(mockDatasource);
+    });
+  });
+
+  describe('getFilterOptionsData', () => {
+    // Since this is a private method, we'll test it indirectly through the public factory method
+    // If you want to test it directly, you might need to make it public or use type assertions
+    
+    it('should transform options correctly (tested through factory)', () => {
+      const mockOptions: IDictionary<boolean> = {
+        active: true,
+        inactive: false,
+      };
+      const mockDatasource = {} as Datasource;
+      
+      mockDatasourceFactory.factory.mockReturnValue(mockDatasource);
+
+      factory.factory(mockOptions);
+
+      expect(mockDatasourceFactory.factory).toHaveBeenCalledWith({
+        data: [
+          { text: 'TEKGRID_active', value: 'active' },
+          { text: 'TEKGRID_inactive', value: 'inactive' },
+        ],
+        loadAll: true,
+        translate: ['text'],
+      });
+    });
+  });
+});

package/tests/unit/components/tek-grid/filter-helper.spec.ts

@@ -1,148 +1,52 @@
-import { Config, DateHelper, dayjs } from '@zeedhi/core';
-import { TekFilterHelper, TekGrid } from '../../../../src';
+import { DateHelper } from '@zeedhi/core';
+import { TekGridColumn, TekFilterHelper } from '../../../../src';
+
+// Mock the DateHelper module
+jest.mock('@zeedhi/core');
 
 describe('TekFilterHelper', () => {
-  describe('getLabel', () => {
-    it('should return helper label', () => {
-      const dateHelperSpy = jest.spyOn(DateHelper, 'getLabel').mockImplementation((name: string) => name);
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
 
-      expect(TekFilterHelper.getLabel('TODAY')).toBe('TODAY');
-      dateHelperSpy.mockClear();
+  describe('getLabel', () => {
+    it('should call DateHelper.getLabel with the provided name', () => {
+      const testName = 'testFilter';
+      TekFilterHelper.getLabel(testName);
+      expect(DateHelper.getLabel).toHaveBeenCalledWith(testName);
     });
   });
 
   describe('getValue', () => {
-    it('should return helper value', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        columns: [
-          {
-            name: 'date',
-            componentProps: {
-              name: 'date-comp',
-              component: 'ZdDate',
-              dateFormat: 'YYYY-MM-DD',
-            },
-          },
-        ],
-      });
-      const today = dayjs().format('YYYY-MM-DD');
-      const tomorrow = dayjs().add(1, 'day').format('YYYY-MM-DD');
-      const yesterday = dayjs().subtract(1, 'day').format('YYYY-MM-DD');
-      const last7Days = [
-        dayjs().subtract(7, 'day').format('YYYY-MM-DD'),
-        dayjs().format('YYYY-MM-DD'),
-      ];
-      const next7Days = [
-        dayjs().format('YYYY-MM-DD'),
-        dayjs().add(7, 'day').format('YYYY-MM-DD'),
-      ];
-      const currentWeek = [
-        dayjs().startOf('week').format('YYYY-MM-DD'),
-        dayjs().endOf('week').format('YYYY-MM-DD'),
-      ];
-      const currentMonth = [
-        dayjs().startOf('month').format('YYYY-MM-DD'),
-        dayjs().endOf('month').format('YYYY-MM-DD'),
-      ];
-      const currentYear = [
-        dayjs().startOf('year').format('YYYY-MM-DD'),
-        dayjs().endOf('year').format('YYYY-MM-DD'),
-      ];
-      expect(TekFilterHelper.getValue('TODAY', grid.columns[0])).toBe(today);
-      expect(TekFilterHelper.getValue('TOMORROW', grid.columns[0])).toBe(tomorrow);
-      expect(TekFilterHelper.getValue('YESTERDAY', grid.columns[0])).toBe(yesterday);
-      expect(TekFilterHelper.getValue('LAST_7_DAYS', grid.columns[0])).toEqual(last7Days);
-      expect(TekFilterHelper.getValue('NEXT_7_DAYS', grid.columns[0])).toEqual(next7Days);
-      expect(TekFilterHelper.getValue('CURRENT_WEEK', grid.columns[0])).toEqual(currentWeek);
-      expect(TekFilterHelper.getValue('CURRENT_MONTH', grid.columns[0])).toEqual(currentMonth);
-      expect(TekFilterHelper.getValue('CURRENT_YEAR', grid.columns[0])).toEqual(currentYear);
-    });
-
-    it('should use default date format if column does not have it', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        columns: [
-          {
-            name: 'date',
-          },
-        ],
-      });
-      const today = dayjs().format(Config.dateFormat);
-      expect(TekFilterHelper.getValue('TODAY', grid.columns[0])).toBe(today);
+    it('should call DateHelper.getValue with name and column dateFormat', () => {
+      const testName = 'testValue';
+      const mockColumn = {
+        componentProps: {
+          dateFormat: 'YYYY-MM-DD'
+        }
+      } as TekGridColumn;
+
+      TekFilterHelper.getValue(testName, mockColumn);
+      expect(DateHelper.getValue).toHaveBeenCalledWith(testName, mockColumn.componentProps.dateFormat);
     });
   });
 
   describe('register', () => {
-    it('should register new functions', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        columns: [
-          {
-            name: 'date',
-            componentProps: {
-              name: 'date-comp',
-              component: 'ZdDate',
-              dateFormat: 'YYYY-MM-DD',
-            },
-          },
-        ],
-      });
+    it('should call DateHelper.register with provided parameters', () => {
+      const testName = 'testRegister';
+      const testLabel = 'Test Register';
+      const testFn = () => new Date();
 
-      TekFilterHelper.register('NEXT_FIFTH_OF_THE_MONTH', 'Next fifth day of the month', () => {
-        const today = dayjs();
-        if (today.date() <= 5) return today.date(5).toDate();
-        return today.add(1, 'month').date(5).toDate();
-      });
-
-      TekFilterHelper.register('NEXT_WEEK', 'Next Week', () => {
-        const startOfNextWeek = dayjs().startOf('week').add(1, 'week').toDate();
-        const endOfNextWeek = dayjs().endOf('week').add(1, 'week').toDate();
-        return [startOfNextWeek, endOfNextWeek];
-      });
-
-      const today = dayjs();
-      let nextFifth = '';
-      if (today.date() <= 5) {
-        nextFifth = today.date(5).format('YYYY-MM-DD');
-      } else {
-        nextFifth = today.add(1, 'month').date(5).format('YYYY-MM-DD');
-      }
-
-      const nextWeek = [
-        dayjs().startOf('week').add(1, 'week').format('YYYY-MM-DD'),
-        dayjs().endOf('week').add(1, 'week').format('YYYY-MM-DD'),
-      ];
-      expect(TekFilterHelper.getValue('NEXT_FIFTH_OF_THE_MONTH', grid.columns[0])).toBe(nextFifth);
-      expect(TekFilterHelper.getValue('NEXT_WEEK', grid.columns[0])).toEqual(nextWeek);
+      TekFilterHelper.register(testName, testLabel, testFn);
+      expect(DateHelper.register).toHaveBeenCalledWith(testName, testLabel, testFn);
     });
   });
 
   describe('unregister', () => {
-    it('should unregister new functions', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        columns: [
-          {
-            name: 'date',
-            componentProps: {
-              name: 'date-comp',
-              component: 'ZdDate',
-              dateFormat: 'YYYY-MM-DD',
-            },
-          },
-        ],
-      });
-
-      TekFilterHelper.unregister('NEXT_FIFTH_OF_THE_MONTH');
-      TekFilterHelper.unregister('NEXT_WEEK');
-
-      expect(TekFilterHelper.getValue('NEXT_FIFTH_OF_THE_MONTH', grid.columns[0])).toBe('');
-      expect(TekFilterHelper.getValue('NEXT_WEEK', grid.columns[0])).toEqual('');
+    it('should call DateHelper.unregister with the provided name', () => {
+      const testName = 'testUnregister';
+      TekFilterHelper.unregister(testName);
+      expect(DateHelper.unregister).toHaveBeenCalledWith(testName);
     });
   });
-});
+});