@zeedhi/teknisa-components-common 1.114.0 → 3.0.0

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

@@ -1,26 +1,23 @@
 /* eslint-disable no-underscore-dangle */
 
 import {
-  Button, Dropdown, IModal, Modal, ModalService, Search, TextInput, Text, Report,
+  Button, Dropdown, type IModal, Modal, ModalService, Search, TextInput, Text, Report,
   AlertService,
   EmptyDataError,
-  IComponentRender,
 } from '@zeedhi/common';
 import {
-  KeyMap, Http, Metadata, IDictionary, IEventParam,
+  KeyMap, Http, Metadata, type IDictionary, type IEventParam,
   Datasource,
   init,
 } from '@zeedhi/core';
 import {
-  ITekGrid,
-  ITekGridFilterButton,
-  ITekGridGroupFooter,
+  type ITekGrid,
+  type ITekGridFilterButton,
   TekGrid, TekGridColumn, TekGridFilterButton, TekRestDatasource,
 } from '../../../../src';
 import { ReportFilter } from '../../../../src/utils';
 import { setClick, getChild } from '../../../__helpers__';
 import { flushPromises } from '../../../__helpers__/flush-promises-helper';
-import { TekGridDeleteRowsError } from '../../../../src/error/delete-rows-error';
 
 jest.mock('lodash.debounce', () => jest.fn((fn) => fn));
 
@@ -47,54 +44,6 @@ const createAndMount = (props: ITekGrid) => {
   return instance;
 };
 
-const createGroupedGrid = async (props: Partial<ITekGrid> = {}) => {
-  const grid = createAndMount({
-    name: 'grid',
-    component: 'TekGrid',
-    columns: [
-      { name: 'id' },
-      { name: 'name' },
-      { name: 'month' },
-      { name: 'department', grouped: true },
-    ],
-    datasource: {
-      uniqueKey: 'id',
-      data: [
-        {
-          id: '1', name: 'First', month: 11, department: 1, salary: 10,
-        },
-        {
-          id: '2', name: 'Second', month: 11, department: 1, salary: 10,
-        },
-        {
-          id: '3', name: 'Third', month: 11, department: 2, salary: 10,
-        },
-        {
-          id: '4', name: 'Fourth', month: 12, department: 1, salary: 10,
-        },
-        {
-          id: '5', name: 'Fifth', month: 12, department: 2, salary: 10,
-        },
-      ],
-    },
-    ...props,
-  });
-
-  await flushPromises();
-  return grid;
-};
-
-const getNthFooter = (grid: TekGrid, n: number): ITekGridGroupFooter => {
-  const { groupedData } = grid;
-
-  return groupedData.filter((row) => row.groupFooter)[n] as ITekGridGroupFooter;
-};
-
-const getLastFooter = (grid: TekGrid) : ITekGridGroupFooter => {
-  const { groupedData } = grid;
-  return groupedData.filter((row) => row.groupFooter).reverse()[0] as ITekGridGroupFooter;
-};
-
 describe('TekGrid', () => {
   beforeEach(() => {
     // clear all metadata instances before testing
@@ -311,34 +260,6 @@ describe('TekGrid', () => {
       spy.mockReset();
     });
 
-    it('when reportLabelFormatter is defined, it should be passed to getReport', async () => {
-      (window as any).open = jest.fn();
-      const reportLabelFormatter = jest.fn();
-      const spy = jest.spyOn(Report.prototype, 'getReport').mockImplementationOnce(async () => '');
-
-      const instance = new TekGrid({
-        reportLabelFormatter,
-        name: 'grid',
-        component: 'TekGrid',
-        columns: [
-          {
-            name: 'id',
-            label: 'ID',
-            aggregation: 'COUNT',
-          },
-          {
-            name: 'department_id',
-            label: 'Department ID',
-            grouped: true,
-          },
-        ],
-      });
-
-      await instance.getReport('pdf');
-
-      expect(spy).toHaveBeenLastCalledWith('pdf', undefined, expect.any(Object), undefined, reportLabelFormatter);
-    });
-
     it('when called with a dynamicFilter, should format the filter values', async () => {
       (window as any).open = jest.fn();
       const spy = jest.spyOn(Report.prototype, 'getReport').mockImplementationOnce(async () => '');
@@ -427,7 +348,7 @@ describe('TekGrid', () => {
         metaData: expect.objectContaining({
           filter,
         }),
-      }), undefined, undefined);
+      }), undefined);
       (window as any).open.mockClear();
       spy.mockReset();
     });
@@ -493,7 +414,7 @@ describe('TekGrid', () => {
         metaData: {
           columns: {}, filter: undefined, groups: [], xlsDefaultType: undefined,
         },
-      }, undefined, undefined);
+      }, undefined);
     });
 
     it('when data is empty, should show alert', async () => {
@@ -539,7 +460,7 @@ describe('TekGrid', () => {
       instance.onCreated();
       const toolbarDiv = instance.toolbarSlot[2];
       if (toolbarDiv.children) {
-        const button = new Button(toolbarDiv.children[10]);
+        const button = new Button(toolbarDiv.children[1]);
         const event = new Event('click');
         button.click(event, {} as HTMLElement);
         expect(spy).toBeCalled();
@@ -563,7 +484,7 @@ describe('TekGrid', () => {
       instance.onCreated();
       const toolbarDiv = instance.toolbarSlot[2];
       if (toolbarDiv.children) {
-        const button = new Button(toolbarDiv.children[10]);
+        const button = new Button(toolbarDiv.children[1]);
         const event = new Event('click');
         button.click(event, {} as HTMLElement);
         expect(beforeSaveCalled).toBeTruthy();
@@ -587,7 +508,7 @@ describe('TekGrid', () => {
       instance.onCreated();
       const toolbarDiv = instance.toolbarSlot[2];
       if (toolbarDiv.children) {
-        const button = new Button(toolbarDiv.children[10]);
+        const button = new Button(toolbarDiv.children[1]);
         button.click({ defaultPrevented: true } as Event, {} as HTMLElement);
         expect(beforeSaveCalled).toBeTruthy();
         expect(afterSaveCalled).toBeFalsy();
@@ -608,7 +529,7 @@ describe('TekGrid', () => {
       instance.onCreated();
       const toolbarDiv = instance.toolbarSlot[2];
       if (toolbarDiv.children) {
-        const button = new Button(toolbarDiv.children[11]);
+        const button = new Button(toolbarDiv.children[2]);
         const event = new Event('click');
         button.click(event, {} as HTMLElement);
         expect(spy).toBeCalled();
@@ -632,7 +553,7 @@ describe('TekGrid', () => {
       instance.onCreated();
       const toolbarDiv = instance.toolbarSlot[2];
       if (toolbarDiv.children) {
-        const button = new Button(toolbarDiv.children[11]);
+        const button = new Button(toolbarDiv.children[2]);
         const event = new Event('click');
         button.click(event, {} as HTMLElement);
         expect(beforeCancelCalled).toBeTruthy();
@@ -656,7 +577,7 @@ describe('TekGrid', () => {
       instance.onCreated();
       const toolbarDiv = instance.toolbarSlot[2];
       if (toolbarDiv.children) {
-        const button = new Button(toolbarDiv.children[11]);
+        const button = new Button(toolbarDiv.children[2]);
         button.click({ defaultPrevented: true } as Event, {} as HTMLElement);
         expect(beforeCancelCalled).toBeTruthy();
         expect(afterCancelCalled).toBeFalsy();
@@ -701,65 +622,57 @@ describe('TekGrid', () => {
     });
   });
 
-  describe('hideButtonClick', () => {
-    it('deve alternar as classes para o estado "escondido" quando a toolbar está visível', () => {
+  describe('hideButtonClick()', () => {
+    it('should hide toolbar', () => {
       const instance = new TekGrid({
-        name: 'grid_hide_test',
+        name: 'grid_deleteClick2',
         component: 'TekGrid',
       });
-      instance.onCreated();
 
-      const mockToolbarDiv = { cssClass: 'toolbar-visible' };
-      const mockIcon = { cssClass: '' };
-      const mockTooltip = { label: 'TEKGRID_HIDE' };
+      instance.onCreated();
 
-      jest.spyOn(Metadata, 'getInstance').mockImplementation((name: string) => {
-        if (name.includes('_toolbarDiv')) return mockToolbarDiv;
-        if (name.includes('_hideButton')) return mockIcon;
-        if (name.includes('_hideTooltip')) return mockTooltip;
-        return null;
-      });
+      const toolbarMock = { isVisible: true };
+      jest.spyOn(Metadata, 'getInstance').mockImplementation(() => toolbarMock);
 
       const hideTooltip = instance.toolbarSlot[1];
-      const hideButtonDef = hideTooltip.children![0];
-      const button = new Button(hideButtonDef);
-      const event = new Event('click');
+      expect(toolbarMock.isVisible).toBeTruthy();
 
-      button.click(event, {} as HTMLElement);
+      if (hideTooltip.children) {
+        const hideButton = hideTooltip.children[0];
+        const button = new Button(hideButton);
+        const event = new Event('click');
+        button.click(event, {} as HTMLElement);
 
-      expect(mockToolbarDiv.cssClass).toBe('');
-      expect(mockIcon.cssClass).toBe('is-rotated');
-      expect(mockTooltip.label).toBe('TEKGRID_SHOW');
+        expect(toolbarMock.isVisible).toBeFalsy();
+      }
     });
 
-    it('deve alternar as classes de volta para o estado "visível" quando a toolbar está escondida', () => {
+    it('should show toolbar', () => {
       const instance = new TekGrid({
-        name: 'grid_show_test',
+        name: 'grid_deleteClick2',
         component: 'TekGrid',
+        toolbarOpened: false,
       });
-      instance.onCreated();
 
-      const mockToolbarDiv = { cssClass: '' };
-      const mockIcon = { cssClass: 'is-rotated' };
-      const mockTooltip = { label: 'TEKGRID_SHOW' };
+      instance.onCreated();
 
-      jest.spyOn(Metadata, 'getInstance').mockImplementation((name: string) => {
-        if (name.includes('_toolbarDiv')) return mockToolbarDiv;
-        if (name.includes('_hideButton')) return mockIcon;
-        if (name.includes('_hideTooltip')) return mockTooltip;
-        return null;
-      });
+      const toolbarMock = { isVisible: true };
+      jest.spyOn(Metadata, 'getInstance').mockImplementation(() => toolbarMock);
 
       const hideTooltip = instance.toolbarSlot[1];
-      const hideButtonDef = hideTooltip.children![0];
-      const button = new Button(hideButtonDef);
-      const event = new Event('click');
 
-      button.click(event, {} as HTMLElement);
+      if (hideTooltip.children) {
+        const hideButton = hideTooltip.children[0];
+        const button = new Button(hideButton);
+        const event = new Event('click');
+        button.click(event, {} as HTMLElement);
+
+        expect(toolbarMock.isVisible).toBeFalsy();
+
+        button.click(event, {} as HTMLElement);
 
-      expect(mockToolbarDiv.cssClass).toBe('toolbar-visible');
-      expect(mockIcon.cssClass).toBe('');
-      expect(mockTooltip.label).toBe('TEKGRID_HIDE');
+        expect(toolbarMock.isVisible).toBeTruthy();
+      }
     });
   });
 
@@ -2015,79 +1928,6 @@ describe('TekGrid', () => {
     });
   });
 
-  describe('updateSummary()', () => {
-    it('should update aggregation data always using the visible cell value', async () => {
-      const instance = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'department', grouped: true },
-          { name: 'salary', aggregation: 'SUM' },
-        ],
-      });
-
-      await flushPromises();
-      instance.buildGroupedData();
-
-      let firstFooter = getNthFooter(instance, 0);
-      let secondFooter = getNthFooter(instance, 1);
-      let thirdFooter = getNthFooter(instance, 2);
-      expect(firstFooter.salary).toBe(30);
-      expect(secondFooter.salary).toBe(20);
-      expect(thirdFooter.salary).toBe(50);
-
-      instance.editing = true;
-      instance.updateCell('1', 'salary', 20);
-
-      instance.updateSummary();
-
-      firstFooter = getNthFooter(instance, 0);
-      secondFooter = getNthFooter(instance, 1);
-      thirdFooter = getNthFooter(instance, 2);
-      expect(firstFooter.salary).toBe(40);
-      expect(secondFooter.salary).toBe(20);
-      expect(thirdFooter.salary).toBe(60);
-    });
-
-    it('should update aggregation data with many groups', async () => {
-      const instance = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-          { name: 'salary', aggregation: 'SUM' },
-        ],
-      });
-
-      await flushPromises();
-      instance.buildGroupedData();
-
-      let firstFooter = getNthFooter(instance, 0);
-      let secondFooter = getNthFooter(instance, 1);
-      let thirdFooter = getNthFooter(instance, 2);
-      let lastFooter = getLastFooter(instance);
-      expect(firstFooter.salary).toBe(20);
-      expect(secondFooter.salary).toBe(10);
-      expect(thirdFooter.salary).toBe(30);
-      expect(lastFooter.salary).toBe(50);
-
-      instance.editing = true;
-      instance.updateCell('1', 'salary', 20);
-
-      instance.updateSummary();
-
-      firstFooter = getNthFooter(instance, 0);
-      secondFooter = getNthFooter(instance, 1);
-      thirdFooter = getNthFooter(instance, 2);
-      lastFooter = getLastFooter(instance);
-      expect(firstFooter.salary).toBe(30);
-      expect(secondFooter.salary).toBe(10);
-      expect(thirdFooter.salary).toBe(40);
-      expect(lastFooter.salary).toBe(60);
-    });
-  });
-
   describe('setSearch()', () => {
     let baseProps: ITekGrid;
     let httpSpy: jest.SpyInstance;
@@ -2273,19 +2113,6 @@ describe('TekGrid', () => {
 
       expect(instance.datasource.page).toBe(1);
     });
-
-    it('deve retornar true se a coluna tiver filtro simples com dados (datasource comum)', () => {
-      const column = { name: 'categoria' } as TekGridColumn;
-      const grid = new TekGrid({ name: 'grid2', component: 'TekGrid' }) as any;
-
-      grid.datasource = {
-        filter: {
-          categoria: ['A'],
-        },
-      };
-
-      expect(grid.columnHasFilterData(column)).toBe(true);
-    });
   });
 
   describe('rowClick', () => {
@@ -2470,6 +2297,7 @@ describe('TekGrid', () => {
         row: grid.groupedData[0],
         component: grid,
       });
+      expect(grid.datasource.currentRow).toEqual({});
     });
 
     it('should not call events.groupRowClick if cellClick prevents it', async () => {
@@ -2544,6 +2372,7 @@ describe('TekGrid', () => {
         row: grid.groupedData[0],
         component: grid,
       });
+      expect(grid.datasource.currentRow).toEqual({});
     });
 
     it('should not call events.groupRowDoubleClick if cellDoubleClick prevents it', async () => {
@@ -2869,509 +2698,4 @@ describe('TekGrid', () => {
       expect(spy).toHaveBeenCalledTimes(1);
     });
   });
-
-  describe('addNewRow', () => {
-    it('when not using groups, should add a new row to the datasource', async () => {
-      const instance = new TekGrid({
-        name: 'Grid',
-        component: 'TekGrid',
-        datasource: {
-          page: 1,
-          data: [
-            { id: 1 },
-          ],
-        },
-      });
-      await instance.datasource.get();
-      const newRow1 = { id: 2 };
-      await instance.addNewRow(newRow1, 'start');
-      expect(instance.datasource.data[0]).toMatchObject({ id: 2, __added_row: true });
-      expect(instance.datasource.data[1]).toMatchObject({ id: 1 });
-    });
-
-    it('should add a new row to the groupedData array', async () => {
-      const grid = await createGroupedGrid();
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 1 },
-        { id: '1', groupHeaders: [{ groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 1 }] },
-        { id: '4', groupHeaders: [{ groupValue: 1 }] },
-        { groupValue: 2 },
-        { id: '3', groupHeaders: [{ groupValue: 2 }] },
-        { id: '5', groupHeaders: [{ groupValue: 2 }] },
-      ]);
-      expect(grid.groupedData[0].children).toMatchObject([
-        { id: '1' },
-        { id: '2' },
-        { id: '4' },
-      ]);
-
-      await grid.addNewRow({ id: '999', name: 'new', department: 1 });
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 1 },
-        { id: '1', groupHeaders: [{ groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 1 }] },
-        { id: '4', groupHeaders: [{ groupValue: 1 }] },
-        { id: '999', groupHeaders: [{ groupValue: 1 }] },
-        { groupValue: 2 },
-        { id: '3', groupHeaders: [{ groupValue: 2 }] },
-        { id: '5', groupHeaders: [{ groupValue: 2 }] },
-      ]);
-      expect(grid.groupedData[0].children).toMatchObject([
-        { id: '1' },
-        { id: '2' },
-        { id: '4' },
-        { id: '999' },
-      ]);
-    });
-
-    it('should add a new row to the groupedData array using nested groups', async () => {
-      const grid = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-        ],
-      });
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 11 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
-        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
-        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
-        { groupValue: 12 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
-        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
-        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
-      ]);
-
-      await grid.addNewRow({
-        id: '999', name: 'new', month: 12, department: 1,
-      }, 'start');
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 11 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
-        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
-        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
-        { groupValue: 12 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
-        { id: '999', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
-        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
-        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
-      ]);
-
-      expect(grid.groupedData[6].children).toMatchObject([
-        { id: '999' },
-        { id: '4' },
-        { id: '5' },
-      ]);
-      expect(grid.groupedData[7].children).toMatchObject([
-        { id: '999' },
-        { id: '4' },
-      ]);
-    });
-
-    it('should add a new row to a group that doesnt exist', async () => {
-      const grid = await createGroupedGrid();
-
-      await grid.addNewRow({ id: '999', name: 'new', department: 999 }, 'end');
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 1 },
-        { id: '1', groupHeaders: [{ groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 1 }] },
-        { id: '4', groupHeaders: [{ groupValue: 1 }] },
-        { groupValue: 2 },
-        { id: '3', groupHeaders: [{ groupValue: 2 }] },
-        { id: '5', groupHeaders: [{ groupValue: 2 }] },
-        { groupValue: 999 },
-        { id: '999', groupHeaders: [{ groupValue: 999 }] },
-      ]);
-    });
-
-    it('should add a new row to a group that doesnt exist using nested groups', async () => {
-      const grid = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-        ],
-      });
-
-      await grid.addNewRow({
-        id: '999', name: 'new', month: 999, department: 1,
-      }, 'end');
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 11 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
-        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
-        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
-        { groupValue: 12 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
-        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
-        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
-        // new group
-        { groupValue: 999 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 999 }] },
-        { id: '999', groupHeaders: [{ groupValue: 999 }, { groupValue: 1 }] },
-      ]);
-    });
-
-    it('should add a new row to a group that doesnt inside a group that exists', async () => {
-      const grid = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-        ],
-      });
-
-      await grid.addNewRow({
-        id: '999', name: 'new', month: 11, department: 999,
-      }, 'end');
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 11 },
-        { groupValue: 999, groupHeaders: [{ groupValue: 11 }] },
-        { id: '999', groupHeaders: [{ groupValue: 11 }, { groupValue: 999 }] },
-        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
-        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
-        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
-        { groupValue: 12 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
-        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
-        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
-      ]);
-    });
-
-    it('should add a new row inside nested groups that doesnt exist', async () => {
-      const grid = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'year', grouped: true },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-        ],
-        datasource: {
-          uniqueKey: 'id',
-          data: [
-            {
-              id: '1', name: 'First', year: 2000, month: 11, department: 1,
-            },
-            {
-              id: '2', name: 'Second', year: 2000, month: 11, department: 1,
-            },
-            {
-              id: '3', name: 'Third', year: 2000, month: 11, department: 2,
-            },
-            {
-              id: '4', name: 'Fourth', year: 2010, month: 11, department: 1,
-            },
-            {
-              id: '5', name: 'Fifth', year: 2010, month: 12, department: 2,
-            },
-          ],
-        },
-      });
-
-      await grid.addNewRow({
-        id: '999', name: 'new', year: 2010, month: 999, department: 999,
-      }, 'end');
-      await grid.addNewRow({
-        id: '998', name: 'new', year: 2010, month: 999, department: 999,
-      }, 'end');
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 2000 },
-        { groupValue: 11, groupHeaders: [{ groupValue: 2000 }] },
-        { groupValue: 1, groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }] },
-        { id: '1', groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }, { groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }] },
-        { id: '3', groupHeaders: [{ groupValue: 2000 }, { groupValue: 11 }, { groupValue: 2 }] },
-        { groupValue: 2010 },
-        { groupValue: 999, groupHeaders: [{ groupValue: 2010 }] },
-        { groupValue: 999, groupHeaders: [{ groupValue: 2010 }, { groupValue: 999 }] },
-        { id: '999', groupHeaders: [{ groupValue: 2010 }, { groupValue: 999 }, { groupValue: 999 }] },
-        { id: '998', groupHeaders: [{ groupValue: 2010 }, { groupValue: 999 }, { groupValue: 999 }] },
-        { groupValue: 11, groupHeaders: [{ groupValue: 2010 }] },
-        { groupValue: 1, groupHeaders: [{ groupValue: 2010 }, { groupValue: 11 }] },
-        { id: '4', groupHeaders: [{ groupValue: 2010 }, { groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 12, groupHeaders: [{ groupValue: 2010 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 2010 }, { groupValue: 12 }] },
-        { id: '5', groupHeaders: [{ groupValue: 2010 }, { groupValue: 12 }, { groupValue: 2 }] },
-      ]);
-    });
-
-    it('should throw an error when row groups are not defined or incomplete', async () => {
-      const grid = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-        ],
-      });
-
-      // month group is undefined, should throw
-      expect(async () => grid.addNewRow({ id: '999', name: 'new', department: 1 }, 'end')).rejects.toThrow();
-    });
-  });
-
-  describe('addToSelection', () => {
-    it('should add a row to the selected group', async () => {
-      const grid = await createGroupedGrid();
-
-      [grid.datasource.currentRow] = grid.groupedData;
-
-      grid.addToSelection({ id: '999', name: 'new', month: 12 });
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 1 },
-        { id: '1', groupHeaders: [{ groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 1 }] },
-        { id: '4', groupHeaders: [{ groupValue: 1 }] },
-        { id: '999', groupHeaders: [{ groupValue: 1 }] },
-        { groupValue: 2 },
-        { id: '3', groupHeaders: [{ groupValue: 2 }] },
-        { id: '5', groupHeaders: [{ groupValue: 2 }] },
-      ]);
-    });
-
-    it('should add a row to the selected group when using nested groups', async () => {
-      const grid = await createGroupedGrid();
-
-      [grid.datasource.currentRow] = grid.groupedData;
-
-      grid.addToSelection({ id: '999', name: 'new', month: 12 });
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 1 },
-        { id: '1', groupHeaders: [{ groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 1 }] },
-        { id: '4', groupHeaders: [{ groupValue: 1 }] },
-        { id: '999', groupHeaders: [{ groupValue: 1 }] },
-        { groupValue: 2 },
-        { id: '3', groupHeaders: [{ groupValue: 2 }] },
-        { id: '5', groupHeaders: [{ groupValue: 2 }] },
-      ]);
-    });
-
-    it('when selected row is not a group, should add a row to the same group as the selected row', async () => {
-      const grid = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-        ],
-      });
-
-      grid.datasource.currentRow = grid.groupedData.find((row) => row.id === '3')!;
-
-      grid.addToSelection({ id: '999', name: 'new', month: 12 });
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 11 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
-        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
-        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
-        { id: '999', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
-        { groupValue: 12 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
-        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
-        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
-      ]);
-    });
-
-    it('when selected row is not the most internal group, should add a row to the first most internal group', async () => {
-      const grid = await createGroupedGrid({
-        columns: [
-          { name: 'id' },
-          { name: 'name' },
-          { name: 'month', grouped: true },
-          { name: 'department', grouped: true },
-        ],
-      });
-
-      [grid.datasource.currentRow] = grid.groupedData;
-
-      grid.addToSelection({ id: '999', name: 'new', month: 12 });
-
-      expect(grid.groupedData).toMatchObject([
-        { groupValue: 11 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 11 }] },
-        { id: '1', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { id: '2', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { id: '999', groupHeaders: [{ groupValue: 11 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 11 }] },
-        { id: '3', groupHeaders: [{ groupValue: 11 }, { groupValue: 2 }] },
-        { groupValue: 12 },
-        { groupValue: 1, groupHeaders: [{ groupValue: 12 }] },
-        { id: '4', groupHeaders: [{ groupValue: 12 }, { groupValue: 1 }] },
-        { groupValue: 2, groupHeaders: [{ groupValue: 12 }] },
-        { id: '5', groupHeaders: [{ groupValue: 12 }, { groupValue: 2 }] },
-      ]);
-    });
-  });
-
-  describe('toolbar creation', () => {
-    it('should render predefined items in toolbarConfig', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        toolbarConfig: ['addButton'],
-      });
-      grid.onCreated();
-
-      expect(grid.toolbarSlot.length).toBe(3);
-      const toolbarDiv = grid.toolbarSlot[2];
-      expect(toolbarDiv.children?.length).toBe(1);
-      expect(toolbarDiv.children?.[0].name).toContain('_add_tooltip');
-    });
-
-    it('should render custom components in toolbarConfig', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        toolbarConfig: [{ component: 'ZdButton', name: 'customButton' }],
-      });
-      grid.onCreated();
-
-      const toolbarDiv = grid.toolbarSlot[2];
-      expect(toolbarDiv.children?.length).toBe(1);
-      expect(toolbarDiv.children?.[0].name).toBe('customButton');
-    });
-
-    it('should alert about invalid items of string type in toolbarConfig', () => {
-      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        toolbarConfig: ['invalidItem'],
-      });
-      grid.onCreated();
-
-      expect(warnSpy).toHaveBeenCalledWith('Predefined toolbar item "invalidItem" not found.');
-      warnSpy.mockRestore();
-    });
-
-    it('should alert about invalid items in toolbarConfig', () => {
-      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        toolbarConfig: [123 as any],
-      });
-      grid.onCreated();
-
-      expect(warnSpy).toHaveBeenCalledWith('Invalid item in toolbarConfig:', 123);
-      warnSpy.mockRestore();
-    });
-  });
-
-  describe('addButtonClick', () => {
-    it('should set editingNewRows as true when editNewRowsOnly is enabled', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        addButton: true,
-        editNewRowsOnly: true,
-      });
-
-      (grid as any).gridBase.addButtonClick({ event: new Event('click') });
-
-      expect((grid as any).editingNewRows).toBe(true);
-    });
-  });
-
-  describe('deleteButtonClick', () => {
-    it('should throw TekGridDeleteRowsError when selectAllPages is true', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-        deleteButton: 'selection',
-        selectAllPages: true,
-      });
-
-      const deleteFn = () => {
-        (grid as any).gridBase.deleteButtonClick({ event: new Event('click') });
-      };
-
-      expect(deleteFn).toThrow(TekGridDeleteRowsError);
-    });
-  });
-
-  describe('reloadGrid', () => {
-    it('should call grid.reload() if beforeReload event is not prevented', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-      });
-      const reloadSpy = jest.spyOn(grid, 'reload');
-      const event = new Event('click');
-
-      (grid as any).gridBase.reloadGrid({ event });
-
-      expect(reloadSpy).toHaveBeenCalledTimes(1);
-
-      reloadSpy.mockRestore();
-    });
-
-    it('should not call grid.reload() if beforeReload event is prevented', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-      });
-      const reloadSpy = jest.spyOn(grid, 'reload');
-      const mockEvent = { defaultPrevented: true };
-
-      (grid as any).gridBase.reloadGrid({ event: mockEvent });
-
-      expect(reloadSpy).not.toHaveBeenCalled();
-
-      reloadSpy.mockRestore();
-    });
-  });
-
-  describe('toolbar creation', () => {
-    it('should create toolbar with default items', () => {
-      const grid = new TekGrid({
-        name: 'grid',
-        component: 'TekGrid',
-      });
-      const { gridBase } = grid as any;
-      delete (gridBase as any).defaultToolbar.title;
-      delete (gridBase as any).defaultToolbar.hideButton;
-
-      const toolbarSlot = gridBase.createToolbarProps();
-
-      expect(toolbarSlot.find((c: IComponentRender) => c.name?.includes('_title'))).toBeUndefined();
-      expect(toolbarSlot.find((c: IComponentRender) => c.name?.includes('_hideTooltip'))).toBeUndefined();
-      expect(toolbarSlot[0].name).toBe('grid_toolbarDiv');
-    });
-  });
 });