@zeedhi/teknisa-components-common 1.117.1 → 3.0.1

package/tests/unit/components/tek-grid/tek-grid-controller.spec.ts

@@ -0,0 +1,253 @@
+import { Loader, SimpleControllerBuilder } from '@zeedhi/core';
+import {
+  ITekGridProps,
+  TekGrid, TekGridController,
+} from '../../../../src';
+
+const setupInstance = (props: Partial<ITekGridProps> = {}) => {
+  const instance = new TekGrid({
+    name: 'Grid',
+    component: 'TekGrid',
+    columns: [
+      { name: 'first' },
+      { name: 'second' },
+      { name: 'third' },
+    ],
+    datasource: {
+      limit: 2,
+      page: 1,
+      data: [
+        { id: 1 },
+        { id: 2 },
+        { id: 3 },
+        { id: 4 },
+        { id: 5 },
+        { id: 6 },
+        { id: 7 },
+      ],
+    },
+    ...props,
+  });
+  const elem = document.createElement('DIV');
+  instance.onCreated();
+  instance.onMounted(elem);
+
+  return instance;
+};
+
+describe('GridController', () => {
+  beforeAll(() => {
+    Loader.setBuilder(new SimpleControllerBuilder());
+  });
+
+  describe('constructor()', () => {
+    it('should create controller and get info from grid', () => {
+      const grid = setupInstance({
+        name: 'Grid',
+        component: 'TekGrid',
+        title: 'title',
+        addButton: false,
+        deleteButton: 'currentRow',
+        filterButton: true,
+        columnsButton: true,
+        editing: true,
+        showEditButtons: false,
+        modalFilterProps: {
+          name: 'name',
+          height: 'auto',
+          persistent: true,
+        },
+        showExport: true,
+        showLayoutOptionsButton: true,
+        showReloadButton: true,
+        actions: [{ name: 'button', component: 'ZdButton' }],
+      });
+      grid.editing = true;
+      const instance = new TekGridController(grid);
+      expect(instance.gridTitle).toBe('title');
+      expect(instance.showAddButton).toBeFalsy();
+      expect(instance.showDeleteButton).toBeTruthy();
+      expect(instance.showFilterButton).toBeTruthy();
+      expect(instance.showActionsButton).toBeTruthy();
+      expect(instance.showExportButton).toBeTruthy();
+      expect(instance.showActionAndExportButton).toBeTruthy();
+      expect(instance.showSearchInput).toBeTruthy();
+      expect(instance.showToolbar).toBeTruthy();
+      expect(instance.toolbarClass).toBe('');
+      expect(instance.tooltipName).toBe('TEKGRID_HIDE');
+      expect(instance.showDivider2).toBeTruthy();
+      expect(instance.showDivider3).toBeTruthy();
+      expect(instance.showColumnsButton).toBeTruthy();
+      expect(instance.columnsButtonIgnore).toEqual([]);
+      expect(instance.showLayoutOptionsButton).toBeTruthy();
+      expect(instance.showReloadButton).toBeTruthy();
+      expect(instance.showDivider1).toBeTruthy();
+      expect(instance.isEditing).toBeTruthy();
+      expect(instance.isNotEditing).toBeFalsy();
+      expect(instance.showEditButtons).toBeFalsy();
+      expect(instance.disableDeleteButton).toBeTruthy();
+      expect(instance.showModalFilterProps).toEqual(
+        expect.objectContaining({
+          height: 'auto',
+          persistent: true,
+        }),
+      );
+
+      grid.datasource.currentRow = { id: '1' };
+      expect(instance.disableDeleteButton).toBeFalsy();
+      grid.showExport = false;
+      grid.showLayoutOptions = false;
+      grid.showReload = false;
+      grid.columnsButton = false;
+      grid.actions = [];
+      grid.deleteButton = 'selection';
+      grid.selectedRows = [{ id: '1' }];
+      expect(instance.disableDeleteButton).toBeFalsy();
+      expect(instance.showExportButton).toBeFalsy();
+      expect(instance.showActionAndExportButton).toBeFalsy();
+      expect(instance.showLayoutOptionsButton).toBeFalsy();
+
+      instance.showToolbar = false;
+      expect(instance.toolbarClass).toBe('is-rotated');
+      expect(instance.tooltipName).toBe('TEKGRID_SHOW');
+      expect(instance.showToolbar).toBeFalsy();
+    });
+
+    it('should verify if showDivider3 is visibility', () => {
+      const grid = setupInstance({
+        name: 'Grid',
+        component: 'TekGrid',
+        addButton: false,
+        deleteButton: 'none',
+        filterButton: false,
+        columnsButton: false,
+        showReload: false,
+        showLayoutOptions: false,
+        showReloadButton: true,
+        showSearch: false,
+        showExport: false,
+        actions: [],
+      });
+      const instance = new TekGridController(grid);
+
+      expect(instance.showDivider3).toBeFalsy();
+      expect(instance.showActionsButton).toBeFalsy();
+      expect(instance.showExportButton).toBeFalsy();
+      expect(instance.showSearchInput).toBeFalsy();
+    });
+
+    it('should verify if showActionAndExportButton is visibility', () => {
+      const grid = setupInstance({
+        name: 'Grid',
+        component: 'TekGrid',
+        addButton: false,
+        deleteButton: 'none',
+        filterButton: false,
+        columnsButton: true,
+        showReload: false,
+        showLayoutOptions: true,
+        showReloadButton: true,
+        showSearch: false,
+        showExport: false,
+        actions: [],
+      });
+      const instance = new TekGridController(grid);
+
+      expect(instance.showActionAndExportButton).toBeFalsy();
+      expect(instance.showActionsButton).toBeFalsy();
+      expect(instance.showSearchInput).toBeFalsy();
+      expect(instance.showExportButton).toBeFalsy();
+    });
+
+    it('should verify if showDivider2 is visibility', () => {
+      const grid = setupInstance({
+        name: 'Grid',
+        component: 'TekGrid',
+        addButton: false,
+        deleteButton: 'none',
+        filterButton: false,
+        columnsButton: false,
+        showReload: true,
+        showLayoutOptions: false,
+        showSearch: false,
+        showExport: false,
+        actions: [],
+      });
+      const instance = new TekGridController(grid);
+
+      expect(instance.showDivider2).toBeFalsy();
+      expect(instance.showActionsButton).toBeFalsy();
+      expect(instance.showSearchInput).toBeFalsy();
+      expect(instance.showColumnsButton).toBeFalsy();
+      expect(instance.showExportButton).toBeFalsy();
+      expect(instance.showReloadButton).toBeTruthy();
+    });
+
+    it('should verify if showDivider1 is visibility', () => {
+      const grid = setupInstance({
+        name: 'Grid',
+        component: 'TekGrid',
+        addButton: true,
+        deleteButton: 'selection',
+        filterButton: false,
+        columnsButton: false,
+        showReload: false,
+        showLayoutOptions: false,
+        showSearch: false,
+        showExport: false,
+        actions: [],
+      });
+      const instance = new TekGridController(grid);
+
+      expect(instance.showDivider1).toBeFalsy();
+      expect(instance.showActionsButton).toBeFalsy();
+      expect(instance.showSearchInput).toBeFalsy();
+      expect(instance.showColumnsButton).toBeFalsy();
+      expect(instance.showExportButton).toBeFalsy();
+      expect(instance.showReloadButton).toBeFalsy();
+    });
+  });
+
+  describe('disableDeleteButton', () => {
+    it('should return true when using selectAllPages and nothing is selected with except equal to 0', () => {
+      const grid = {
+        selectAllPages: true,
+        deleteButton: 'selection',
+        selectionState: { allSelected: false, except: [] },
+        datasource: {
+          total: 1,
+        },
+      } as any as TekGrid;
+
+      const controller = new TekGridController(grid);
+
+      expect(controller.disableDeleteButton).toBeTruthy();
+    });
+
+    it('should return true when using selectAllPages and nothing is selected', () => {
+      const data = [{ id: '1' }];
+      const grid = {
+        selectAllPages: true,
+        deleteButton: 'selection',
+        selectionState: { allSelected: true, except: data },
+        datasource: {
+          total: 1,
+        },
+      } as any as TekGrid;
+
+      const controller = new TekGridController(grid);
+
+      expect(controller.disableDeleteButton).toBeTruthy();
+    });
+
+    it('should return false when deleteButton mode is none', () => {
+      const grid = {
+        deleteButton: 'none',
+      } as any as TekGrid;
+
+      const controller = new TekGridController(grid);
+
+      expect(controller.disableDeleteButton).toBeFalsy();
+    });
+  });
+});

package/tests/unit/components/tek-grid/tek-grid-events.spec.ts

@@ -0,0 +1,186 @@
+import { ITekGrid, ITekGridSummary, TekGridColumn, TekGridEvents } from '../../../../src';
+
+describe('TekGridEvents', () => {
+  let tekGridEvents: TekGridEvents;
+  let mockTekGrid: jest.Mocked<ITekGrid>;
+  const mockEvent = {} as Event;
+  const mockElement = {} as HTMLElement;
+  const mockRow = { id: 1, name: 'Test Row' };
+  const mockGroupRow = { group: true, groupValue: 'Test Group' };
+
+  beforeEach(() => {
+    mockTekGrid = {
+      datasource: { currentRow: null },
+      callEvent: jest.fn(),
+    } as unknown as jest.Mocked<ITekGrid>;
+
+    tekGridEvents = new TekGridEvents(mockTekGrid);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with the provided tekGrid', () => {
+      expect(tekGridEvents).toBeInstanceOf(TekGridEvents);
+      // @ts-ignore - access protected property for testing
+      expect(tekGridEvents.tekGrid).toBe(mockTekGrid);
+    });
+  });
+
+  describe('calcSummary', () => {
+    it('should call calcSummary event with correct parameters', () => {
+      const mockColumn = { name: 'testColumn' } as TekGridColumn;
+      const mockSummary: ITekGridSummary = { sum: 0, count: 0, avg: 0, min: 0, max: 0 };
+      const mockRowWithValue = { testColumn: 100 };
+
+      tekGridEvents.calcSummary(mockColumn, mockSummary, mockRowWithValue);
+
+      expect(mockTekGrid.callEvent).toHaveBeenCalledWith('calcSummary', {
+        component: mockTekGrid,
+        column: mockColumn,
+        columnName: 'testColumn',
+        summary: mockSummary,
+        row: mockRowWithValue,
+        rowValue: 100,
+      });
+    });
+  });
+
+  describe('rowDoubleClick', () => {
+    it('should set currentRow and dispatch event when not prevented', () => {
+      tekGridEvents.rowDoubleClick(mockRow, mockEvent, mockElement);
+
+      expect(mockTekGrid.datasource.currentRow).toBe(mockRow);
+      expect(mockTekGrid.callEvent).toHaveBeenCalledWith('rowDoubleClick', {
+        event: mockEvent,
+        element: mockElement,
+        row: mockRow,
+        component: mockTekGrid,
+        column: undefined,
+      });
+    });
+
+    it('should not dispatch event when prevented', () => {
+      // @ts-ignore - access protected property for testing
+      tekGridEvents.preventRowDoubleClick = true;
+      tekGridEvents.rowDoubleClick(mockRow, mockEvent, mockElement);
+
+      expect(mockTekGrid.callEvent).not.toHaveBeenCalled();
+      // Should still reset the flag
+      // @ts-ignore - access protected property for testing
+      expect(tekGridEvents.preventRowDoubleClick).toBe(false);
+    });
+  });
+
+  describe('groupRowClick', () => {
+    it('should dispatch groupRowClick event when not prevented', () => {
+      tekGridEvents.groupRowClick(mockGroupRow, mockEvent, mockElement);
+
+      expect(mockTekGrid.callEvent).toHaveBeenCalledWith('groupRowClick', {
+        event: mockEvent,
+        element: mockElement,
+        row: mockGroupRow,
+        component: mockTekGrid,
+        column: undefined,
+      });
+    });
+
+    it('should not dispatch event when prevented', () => {
+      // @ts-ignore - access protected property for testing
+      tekGridEvents.preventRowClick = true;
+      tekGridEvents.groupRowClick(mockGroupRow, mockEvent, mockElement);
+
+      expect(mockTekGrid.callEvent).not.toHaveBeenCalled();
+      // Should still reset the flag
+      // @ts-ignore - access protected property for testing
+      expect(tekGridEvents.preventRowClick).toBe(false);
+    });
+  });
+
+  describe('groupRowDoubleClick', () => {
+    it('should dispatch groupRowDoubleClick event when not prevented', () => {
+      tekGridEvents.groupRowDoubleClick(mockGroupRow, mockEvent, mockElement);
+
+      expect(mockTekGrid.callEvent).toHaveBeenCalledWith('groupRowDoubleClick', {
+        event: mockEvent,
+        element: mockElement,
+        row: mockGroupRow,
+        component: mockTekGrid,
+        column: undefined,
+      });
+    });
+
+    it('should not dispatch event when prevented', () => {
+      // @ts-ignore - access protected property for testing
+      tekGridEvents.preventRowDoubleClick = true;
+      tekGridEvents.groupRowDoubleClick(mockGroupRow, mockEvent, mockElement);
+
+      expect(mockTekGrid.callEvent).not.toHaveBeenCalled();
+      // Should still reset the flag
+      // @ts-ignore - access protected property for testing
+      expect(tekGridEvents.preventRowDoubleClick).toBe(false);
+    });
+  });
+
+  describe('selectGroupClick', () => {
+    it('should dispatch groupSelected event when isSelected is true', () => {
+      tekGridEvents.selectGroupClick(mockGroupRow, true, mockEvent, mockElement);
+
+      expect(mockTekGrid.callEvent).toHaveBeenCalledWith('groupSelected', {
+        event: mockEvent,
+        element: mockElement,
+        row: mockGroupRow,
+        component: mockTekGrid,
+        column: undefined,
+      });
+      expect(mockTekGrid.callEvent).not.toHaveBeenCalledWith('groupUnselected', expect.anything());
+    });
+
+    it('should dispatch groupUnselected event when isSelected is false', () => {
+      tekGridEvents.selectGroupClick(mockGroupRow, false, mockEvent, mockElement);
+
+      expect(mockTekGrid.callEvent).toHaveBeenCalledWith('groupUnselected', {
+        event: mockEvent,
+        element: mockElement,
+        row: mockGroupRow,
+        component: mockTekGrid,
+        column: undefined,
+      });
+      expect(mockTekGrid.callEvent).not.toHaveBeenCalledWith('groupSelected', expect.anything());
+    });
+
+    it('should pass through all parameters correctly', () => {
+      const customEvent = { type: 'click' } as Event;
+      const customElement = { tagName: 'DIV' } as HTMLElement;
+      const customRow = { group: true, groupValue: 'Custom Group' };
+
+      tekGridEvents.selectGroupClick(customRow, true, customEvent, customElement);
+
+      expect(mockTekGrid.callEvent).toHaveBeenCalledWith('groupSelected', {
+        event: customEvent,
+        element: customElement,
+        row: customRow,
+        component: mockTekGrid,
+        column: undefined,
+      });
+    });
+  });
+
+  describe('prevention flags', () => {
+    it('should properly reset prevention flags after operations', () => {
+      // Set flags to true
+      // @ts-ignore - access protected properties for testing
+      tekGridEvents.preventRowClick = true;
+      // @ts-ignore - access protected properties for testing
+      tekGridEvents.preventRowDoubleClick = true;
+
+      // Trigger events that should reset them
+      tekGridEvents.groupRowClick(mockGroupRow, mockEvent, mockElement);
+      tekGridEvents.rowDoubleClick(mockRow, mockEvent, mockElement);
+
+      // Verify flags were reset
+      // @ts-ignore - access protected properties for testing
+      expect(tekGridEvents.preventRowClick).toBe(false);
+      // @ts-ignore - access protected properties for testing
+      expect(tekGridEvents.preventRowDoubleClick).toBe(false);
+    });
+  });
+});

package/tests/unit/components/tek-grid/tek-grid-toolbar-provider.spec.ts

@@ -0,0 +1,34 @@
+import { Metadata } from '@zeedhi/core';
+import { TekGridToolbarProvider } from '../../../../src';
+
+describe('TekGridColumnsButton', () => {
+  describe('getAtomInstance()', () => {
+    it('when called, should call Metadata.getInstance passing the name of the atom', () => {
+      const mockGrid = { name: 'name' } as any;
+      const toolbarProvider = new TekGridToolbarProvider(mockGrid, 'show');
+      const spy = jest.spyOn(Metadata, 'getInstance').mockImplementation(() => {});
+      toolbarProvider.getAtomInstance('TITLE');
+      expect(spy).toHaveBeenCalledWith('name_gridTitle');
+    });
+  });
+
+  describe('reloadGrid()', () => {
+    it('when called, should call grid.reload', () => {
+      const mockGrid = { reload: jest.fn(), callEvent: jest.fn() } as any;
+      const toolbarProvider = new TekGridToolbarProvider(mockGrid, 'show');
+      toolbarProvider.reloadGrid({ event: { defaultPrevented: false } } as any);
+
+      expect(mockGrid.callEvent).toHaveBeenCalled();
+      expect(mockGrid.reload).toHaveBeenCalled();
+    });
+
+    it('when called with defaultPrevented, should not call grid.reload', () => {
+      const mockGrid = { reload: jest.fn(), callEvent: jest.fn() } as any;
+      const toolbarProvider = new TekGridToolbarProvider(mockGrid, 'show');
+      toolbarProvider.reloadGrid({ event: { defaultPrevented: true } } as any);
+
+      expect(mockGrid.callEvent).toHaveBeenCalled();
+      expect(mockGrid.reload).not.toHaveBeenCalled();
+    });
+  });
+});