@zeedhi/teknisa-components-common 3.0.4 → 3.2.0

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

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