@zeedhi/teknisa-components-common 3.0.0 → 3.0.1

package/tests/unit/components/tek-grid/grouped-data-manager.spec.ts

@@ -0,0 +1,593 @@
+import { IDictionary } from 'packages/core/dist/types';
+import { GroupedDataManager, TekGridColumn } from '../../../../src';
+
+jest.mock('lodash.debounce', () => jest.fn((fn) => fn));
+
+// 🟡 PARTIAL MOCK for I18n.translate from @zeedhi/core
+import { I18n } from '@zeedhi/core';
+jest.spyOn(I18n, 'translate').mockImplementation((label: string | string[]) => `translated_${label}`);
+
+const createMockGrid = (): any => ({
+  columns: [],
+  datasource: {
+    order: [],
+    loadAll: false,
+    limit: 100,
+    registerGetCallback: jest.fn(),
+  },
+  getColumn(name: string) { return this.columns.find((column: any) => column.name === name); },
+  getData: jest.fn(() => []),
+  setOrder: jest.fn(),
+  showSummaryTotal: false,
+  virtualScroll: false,
+  groupsOpened: true,
+  events: {},
+  reload: jest.fn(),
+  reapplyConditions: jest.fn(),
+  getAppliedConditions: jest.fn(() => ({})),
+  calcSummary: jest.fn()
+});
+
+describe('GroupedDataManager', () => {
+  let mockGrid: any;
+  let manager: GroupedDataManager;
+
+  beforeEach(() => {
+    mockGrid = createMockGrid();
+    manager = new GroupedDataManager(mockGrid);
+    manager.initializeGrouping(false);
+  });
+
+  describe('registerTask', () => {
+    it('should store tasks to be executed before loading', async () => {
+      const task = Promise.resolve('ok');
+      manager.registerTask(task);
+      await manager.loadAfterTasks();
+      expect(mockGrid.reload).toHaveBeenCalled();
+    });
+
+    it('should ignore errors from tasks and still reload', async () => {
+      const failingTask = Promise.reject(new Error('Task failed'));
+      const successfulTask = Promise.resolve('success');
+
+      manager.registerTask(failingTask);
+      manager.registerTask(successfulTask);
+
+      await manager.loadAfterTasks();
+
+      expect(mockGrid.reload).toHaveBeenCalled();
+      expect(manager['tasksBeforeLoad']).toHaveLength(0);
+    });
+  });
+
+  describe('loadAfterTasks', () => {
+    it('should throw when manager is not initialized', async () => {
+      const manager = new GroupedDataManager(mockGrid);
+
+      expect(async () => await manager.loadAfterTasks()).rejects.toThrow();
+    });
+  });
+
+  describe('initializeGrouping', () => {
+    it('should initialize group and summary columns and register callback', () => {
+      mockGrid.columns = [
+        new TekGridColumn({ grouped: true, name: 'foo', label: 'Foo', groupOpened: true }, mockGrid),
+        new TekGridColumn({ grouped: false, name: 'bar', aggregation: 'SUM' }, mockGrid)
+      ];
+      manager.initializeGrouping(false);
+      expect(mockGrid.datasource.registerGetCallback).toHaveBeenCalled();
+      expect(manager['groupColumns'].length).toBe(1);
+      expect(manager['summaryColumns'].length).toBe(1);
+    });
+
+    it('should register callback for datasource.get', () => {
+      mockGrid.showSummaryTotal = true;
+      mockGrid.columns = [
+        new TekGridColumn({ grouped: true, name: 'foo', label: 'Foo', groupOpened: true }, mockGrid),
+        new TekGridColumn({ grouped: false, name: 'bar', aggregation: 'SUM' }, mockGrid)
+      ];
+      mockGrid.datasource.registerGetCallback = jest.fn().mockImplementation((fn: (data: IDictionary[]) => unknown) => {
+        fn([]);
+      });
+      manager.buildGroupedData = jest.fn();
+
+      manager.initializeGrouping(false);
+
+      expect(mockGrid.datasource.registerGetCallback).toHaveBeenCalled();
+
+      expect(manager.buildGroupedData).toHaveBeenCalled();
+    });
+  });
+
+  describe('updateGroupedData', () => {
+    it('should reload data and call view updates', async () => {
+      const scrollMock = jest.fn();
+      const fixedMock = jest.fn();
+
+      manager.setViewUpdateScrollData(scrollMock);
+      manager.setViewUpdateFixedColumns(fixedMock);
+
+      await manager.updateGroupedData(false);
+      expect(mockGrid.reload).toHaveBeenCalled();
+      expect(fixedMock).toHaveBeenCalled();
+    });
+
+    it('should call viewUpdateScrollData when using virtual scroll', async () => {
+      const scrollMock = jest.fn();
+      manager.setViewUpdateScrollData(scrollMock);
+      mockGrid.virtualScroll = true;
+
+      await manager.updateGroupedData(false);
+      expect(scrollMock).toHaveBeenCalled();
+    });
+  });
+
+  describe('getOrder', () => {
+    it('should prioritize group columns in the order list', () => {
+      const order = manager['getOrder'](['a'], ['b.desc', 'a.desc']);
+      expect(order).toEqual(['a.asc', 'b.desc']);
+    });
+  });
+
+  describe('getSummaryData', () => {
+    it('should return extracted summary values for SUM aggregation', () => {
+      const column = new TekGridColumn({ name: 'amount', aggregation: 'SUM' }, mockGrid);
+      manager.summaryColumns = [column];
+  
+      const footer = {
+        amount: { sum: 100, count: 5 }
+      };
+  
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ amount: 100 });
+    });
+  
+    it('should return extracted summary values for COUNT aggregation', () => {
+      const column = new TekGridColumn({ name: 'items', aggregation: 'COUNT' }, mockGrid);
+      manager.summaryColumns = [column];
+  
+      const footer = {
+        items: { sum: 10, count: 3 }
+      };
+  
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ items: 3 });
+    });
+  
+    it('should return 0 if summary key is missing in footer', () => {
+      const column = new TekGridColumn({ name: 'missing', aggregation: 'SUM' }, mockGrid);
+      manager.summaryColumns = [column];
+  
+      const footer = {
+        someOtherField: { sum: 99, count: 1 }
+      };
+  
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ missing: 0 });
+    });
+  
+    it('should handle multiple columns with different aggregations', () => {
+      const amountCol = new TekGridColumn({ name: 'amount', aggregation: 'SUM' }, mockGrid);
+      const itemsCol = new TekGridColumn({ name: 'items', aggregation: 'COUNT' }, mockGrid);
+  
+      manager.summaryColumns = [amountCol, itemsCol];
+  
+      const footer = {
+        amount: { sum: 200, count: 2 },
+        items: { sum: 50, count: 10 }
+      };
+  
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ amount: 200, items: 10 });
+    });
+
+    it('should return AVG when aggregation is AVG', () => {
+      const column = new TekGridColumn({ name: 'score', aggregation: 'AVG' }, mockGrid);
+      manager.summaryColumns = [column];
+    
+      const footer = {
+        score: { sum: 90, count: 3 }
+      };
+    
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ score: 30 });
+    });
+    
+    it('should return AVG when avg prop is defined in summary', () => {
+      const column = new TekGridColumn({ name: 'score', aggregation: 'AVG' }, mockGrid);
+      manager.summaryColumns = [column];
+    
+      const footer = {
+        score: { sum: 90, count: 10, avg: 9 }
+      };
+    
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ score: 9 });
+    });
+    
+    it('should return MIN when aggregation is MIN', () => {
+      const column = new TekGridColumn({ name: 'score', aggregation: 'MIN' }, mockGrid);
+      manager.summaryColumns = [column];
+    
+      const footer = {
+        score: { sum: 100, count: 2, min: 40 }
+      };
+    
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ score: 40 });
+    });
+    
+    it('should return MAX when aggregation is MAX', () => {
+      const column = new TekGridColumn({ name: 'score', aggregation: 'MAX' }, mockGrid);
+      manager.summaryColumns = [column];
+    
+      const footer = {
+        score: { sum: 100, count: 2, max: 60 }
+      };
+    
+      const result = manager.getSummaryData(footer as any);
+      expect(result).toEqual({ score: 60 });
+    });
+  });
+
+  describe('buildGroupedData', () => {
+    it('should initialize groups and build grouped data structure', () => {
+      mockGrid.showSummaryTotal = true;
+      mockGrid.columns = [
+        new TekGridColumn({ name: 'group1Col', grouped: true, label: 'Group' }, mockGrid),
+        new TekGridColumn({ name: 'group2Col', grouped: true, label: 'Group' }, mockGrid),
+        new TekGridColumn({ name: 'valueCol', aggregation: 'SUM' }, mockGrid)
+      ];
+      mockGrid.getData.mockReturnValue([
+        { group1Col: 'A', group2Col: 'B', valueCol: 10 },
+        { group1Col: 'A', group2Col: 'B', valueCol: 20 },
+      ]);
+
+      manager.initializeGrouping(false);
+      manager.buildGroupedData();
+      const data = manager.getGroupedData();
+      expect(data).toMatchObject([
+        { group: true, groupHeader: true, groupColumnName: 'group1Col' },
+        { group: true, groupHeader: true, groupColumnName: 'group2Col' },
+        { group1Col: 'A', group2Col: 'B', valueCol: 10 },
+        { group1Col: 'A', group2Col: 'B', valueCol: 20 },
+        { groupFooter: true, groupValue: 'B' }, 
+        { groupFooter: true, groupValue: 'A' }, 
+        { groupFooter: true, groupSummary: true, valueCol: 30 },
+      ]);
+    });
+
+    it('should initialize groups without summary', () => {
+      mockGrid.columns = [
+        new TekGridColumn({ name: 'groupCol', grouped: true, label: 'Group' }, mockGrid),
+      ];
+      mockGrid.getData.mockReturnValue([
+        { groupCol: 'A' },
+        { groupCol: 'A' },
+      ]);
+
+      manager.initializeGrouping(false);
+      manager.buildGroupedData();
+      const data = manager.getGroupedData();
+      expect(data.length).toBeGreaterThan(0);
+    });
+
+    it('should not calculate when row value is Nil', () => {
+      mockGrid.showSummaryTotal = true;
+      mockGrid.columns = [
+        new TekGridColumn({ name: 'groupCol', grouped: true, label: 'Group' }, mockGrid),
+        new TekGridColumn({ name: 'valueCol', aggregation: 'SUM' }, mockGrid)
+      ];
+      mockGrid.getData.mockReturnValue([
+        { groupCol: 'A', valueCol: null },
+        { groupCol: 'A', valueCol: 20 },
+      ]);
+
+      manager.initializeGrouping(false);
+      manager.buildGroupedData();
+      const data = manager.getGroupedData();
+      expect(data).toMatchObject([
+        { group: true, groupHeader: true, groupColumnName: 'groupCol' },
+        { groupCol: 'A', valueCol: null },
+        { groupCol: 'A', valueCol: 20 },
+        { groupFooter: true, groupValue: 'A' }, 
+        { groupFooter: true, groupSummary: true, valueCol: 20 },
+      ]);
+    });
+
+    it('when calcSummary event is defined, should call the event', () => {
+      const spy = jest.fn();
+      mockGrid.events.calcSummary = spy;
+      mockGrid.showSummaryTotal = true;
+      mockGrid.columns = [
+        new TekGridColumn({ name: 'groupCol', grouped: true, label: 'Group' }, mockGrid),
+        new TekGridColumn({ name: 'valueCol', aggregation: 'SUM' }, mockGrid)
+      ];
+      mockGrid.getData.mockReturnValue([
+        { groupCol: 'A', valueCol: 10 },
+        { groupCol: 'A', valueCol: 20 },
+      ]);
+
+      manager.initializeGrouping(false);
+      manager.buildGroupedData();
+      expect(mockGrid.calcSummary).toHaveBeenCalled();
+    });
+
+    it('should not add a summary footer when grid has no summary columns', () => {
+      mockGrid.showSummaryTotal = true;
+      mockGrid.columns = [
+        new TekGridColumn({ name: 'groupCol', grouped: true, label: 'Group' }, mockGrid),
+        new TekGridColumn({ name: 'valueCol' }, mockGrid)
+      ];
+      mockGrid.getData.mockReturnValue([
+        { groupCol: 'A', valueCol: 10 },
+        { groupCol: 'A', valueCol: 20 },
+      ]);
+
+      manager.initializeGrouping(false);
+      manager.buildGroupedData();
+      const data = manager.getGroupedData();
+      expect(data).toMatchObject([
+        { group: true, groupHeader: true, groupColumnName: 'groupCol' },
+        { groupCol: 'A', valueCol: 10 },
+        { groupCol: 'A', valueCol: 20 },
+      ]);
+    });
+
+    it('should use groupLabelForEmptyValue when group header value is empty', () => {
+      mockGrid.showSummaryTotal = true;
+      mockGrid.columns = [
+        new TekGridColumn({ name: 'groupCol', groupLabelForEmptyValue: 'Empty', grouped: true }, mockGrid),
+        new TekGridColumn({ name: 'valueCol', aggregation: 'SUM' }, mockGrid)
+      ];
+      mockGrid.getData.mockReturnValue([
+        { groupCol: '', valueCol: 10 },
+      ]);
+
+      manager.initializeGrouping(false);
+      manager.buildGroupedData();
+      const data = manager.getGroupedData();
+      expect(data).toMatchObject([
+        { group: true, groupHeader: true, groupColumnName: 'groupCol', groupValue: 'Empty' },
+        { groupCol: '', valueCol: 10 },
+        { groupFooter: true, groupValue: 'Empty' },
+        { groupFooter: true, groupSummary: true, valueCol: 10 },
+      ]);
+    });
+
+    it('when using a min aggregation, should use the min value', () => {
+      mockGrid.showSummaryTotal = true;
+      mockGrid.columns = [
+        new TekGridColumn({ name: 'groupCol', grouped: true, label: 'Group' }, mockGrid),
+        new TekGridColumn({ name: 'valueCol', aggregation: 'MIN' }, mockGrid)
+      ];
+      mockGrid.getData.mockReturnValue([
+        { groupCol: 'A', valueCol: 20 },
+        { groupCol: 'A', valueCol: 10 },
+      ]);
+
+      manager.initializeGrouping(false);
+      manager.buildGroupedData();
+      const data = manager.getGroupedData();
+      expect(data).toMatchObject([
+        { group: true, groupHeader: true, groupColumnName: 'groupCol' },
+        { groupCol: 'A', valueCol: 20 },
+        { groupCol: 'A', valueCol: 10 },
+        { groupFooter: true, groupValue: 'A' }, 
+        { groupFooter: true, groupSummary: true, valueCol: 10 },
+      ]);
+    });
+  });
+
+  describe('updateGrouping', () => {
+    it('when lazyLoad is undefined, should call updateGroupedData with lazyLoad=false', () => {
+      const updateGroupedDataSpy = jest.spyOn(manager, 'updateGroupedData');
+      manager.updateGrouping();
+      expect(updateGroupedDataSpy).toHaveBeenCalledWith(false);
+    });
+
+    it('should throw when manager is not initialized', () => {
+      const manager = new GroupedDataManager(mockGrid);
+      expect(() => manager.updateGrouping()).toThrow();
+    });
+  });
+
+  describe('openGroup', () => {
+    it('should toggle groupOpened from false to true', () => {
+      const group = { groupOpened: false };
+      manager.openGroup(group);
+      expect(group.groupOpened).toBe(true);
+    });
+  
+    it('should toggle groupOpened from true to false', () => {
+      const group = { groupOpened: true };
+      manager.openGroup(group);
+      expect(group.groupOpened).toBe(false);
+    });
+  
+    it('should not call viewUpdateScrollData if virtualScroll is false', () => {
+      const group = { groupOpened: false };
+      const spy = jest.fn();
+      manager.setViewUpdateScrollData(spy);
+      manager.openGroup(group);
+      expect(spy).not.toHaveBeenCalled();
+    });
+  
+    it('should call viewUpdateScrollData if virtualScroll is true and method is defined', () => {
+      manager = new GroupedDataManager({ virtualScroll: true } as any);
+      const spy = jest.fn();
+      manager.setViewUpdateScrollData(spy);
+  
+      const group = { groupOpened: false };
+      manager.openGroup(group);
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+  
+    it('should not throw if viewUpdateScrollData is undefined and virtualScroll is true', () => {
+      manager = new GroupedDataManager({ virtualScroll: true } as any);
+      const group = { groupOpened: false };
+      expect(() => manager.openGroup(group)).not.toThrow();
+    });
+  });
+
+  describe('isItemVisible', () => {
+    it('should return true if row.groupHeaders is undefined', () => {
+      const row = {};
+      expect(manager.isItemVisible(row)).toBe(true);
+    });
+  
+    it('should return true if row.groupHeaders is null', () => {
+      const row = { groupHeaders: null };
+      expect(manager.isItemVisible(row)).toBe(true);
+    });
+  
+    it('should return true if row.groupHeaders is an empty array', () => {
+      const row = { groupHeaders: [] };
+      expect(manager.isItemVisible(row)).toBe(true);
+    });
+  
+    it('should return true if all groupHeaders are opened', () => {
+      const row = {
+        groupHeaders: [
+          { groupOpened: true },
+          { groupOpened: true },
+        ]
+      };
+      expect(manager.isItemVisible(row)).toBe(true);
+    });
+  
+    it('should return false if at least one groupHeader is closed', () => {
+      const row = {
+        groupHeaders: [
+          { groupOpened: true },
+          { groupOpened: false },
+        ]
+      };
+      expect(manager.isItemVisible(row)).toBe(false);
+    });
+  
+    it('should return false if all groupHeaders are closed', () => {
+      const row = {
+        groupHeaders: [
+          { groupOpened: false },
+          { groupOpened: false },
+        ]
+      };
+      expect(manager.isItemVisible(row)).toBe(false);
+    });
+  });
+
+  describe('isColumnSearchable', () => {
+    const makeColumn = (props: Partial<TekGridColumn> = {}) => ({
+      isVisible: false,
+      grouped: false,
+      ...props,
+    } as TekGridColumn);
+
+    it('should return true if searchVisibleOnly is false (regardless of column)', () => {
+      mockGrid.searchVisibleOnly = false;
+      const column = makeColumn({ isVisible: false, grouped: false });
+      expect(manager.isColumnSearchable(column)).toBe(true);
+    });
+  
+    it('should return true if column.isVisible is true', () => {
+      const column = makeColumn({ isVisible: true, grouped: false });
+      expect(manager.isColumnSearchable(column)).toBe(true);
+    });
+  
+    it('should return true if column.grouped is true', () => {
+      const column = makeColumn({ isVisible: false, grouped: true });
+      expect(manager.isColumnSearchable(column)).toBe(true);
+    });
+  
+    it('should return false if searchVisibleOnly is true and column is neither visible nor grouped', () => {
+      mockGrid.searchVisibleOnly = true;
+      const column = makeColumn({ isVisible: false, grouped: false });
+      expect(manager.isColumnSearchable(column)).toBe(false);
+    });
+  });
+
+  describe('directionalLeft', () => {
+    let mockSetCurrentRow: jest.Mock;
+  
+    beforeEach(() => {
+      mockSetCurrentRow = jest.fn();
+
+      mockGrid.setCurrentRow = mockSetCurrentRow;
+    });
+
+    it('should close the group if current row is a group and is open', () => {
+      const currentRow = { group: true, groupOpened: true };
+      mockGrid.datasource.currentRow = currentRow;
+  
+      manager.directionalLeft();
+  
+      expect(mockGrid.datasource.currentRow.groupOpened).toBe(false);
+      expect(mockSetCurrentRow).not.toHaveBeenCalled();
+    });
+  
+    it('should do nothing if grid.cellSelection is true', () => {
+      mockGrid.cellSelection = true;
+      mockGrid.datasource.currentRow = {
+        groupHeaders: [{}],
+      };
+  
+      manager.directionalLeft();
+  
+      expect(mockSetCurrentRow).not.toHaveBeenCalled();
+    });
+  
+    it('should do nothing if there are no groupHeaders', () => {
+      mockGrid.datasource.currentRow = {
+        groupHeaders: [],
+      };
+  
+      manager.directionalLeft();
+  
+      expect(mockSetCurrentRow).not.toHaveBeenCalled();
+    });
+  
+    it('should move to the last groupHeader if not in a group and no cell selection', () => {
+      const groupHeader1 = { id: 1 };
+      const groupHeader2 = { id: 2 };
+      const currentRow = {
+        groupHeaders: [groupHeader1, groupHeader2],
+      };
+  
+      mockGrid.datasource.currentRow = currentRow;
+  
+      manager.directionalLeft();
+  
+      expect(mockSetCurrentRow).toHaveBeenCalledWith(groupHeader2);
+    });
+  });
+
+  describe('directionalRight', () => {
+    it('should do nothing if currentRow.group is falsy', () => {
+      const row = { group: false, groupOpened: true };
+      mockGrid.datasource.currentRow = row;
+  
+      manager.directionalRight();
+  
+      expect(row.groupOpened).toBe(true); // unchanged
+    });
+  
+    it('should do nothing if currentRow.groupOpened is true', () => {
+      const row = { group: true, groupOpened: true };
+      mockGrid.datasource.currentRow = row;
+  
+      manager.directionalRight();
+  
+      expect(row.groupOpened).toBe(true); // still true
+    });
+  
+    it('should set groupOpened to true if group and groupOpened are already true', () => {
+      const row = { group: true, groupOpened: false };
+      mockGrid.datasource.currentRow = row;
+  
+      manager.directionalRight();
+  
+      expect(row.groupOpened).toBe(true); // remains true
+    });
+  });
+});