@zeedhi/teknisa-components-common 1.117.1 → 3.0.1

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

@@ -0,0 +1,895 @@
+/* eslint-disable no-underscore-dangle */
+
+import {
+  Button,
+  TekGrid, TekGridColumn,
+  ComponentRender,
+  ITekGridAtoms,
+  TekRestDatasource,
+  DynamicFilterDatasourceFactory,
+  KeyMapMerger,
+  TekMemoryDatasource,
+  ITekGridProps,
+} from '../../../../src';
+import {
+  Metadata, 
+  Datasource,
+  Loader,
+  SimpleControllerBuilder,
+  Newable,
+} from '@zeedhi/core';
+import {
+  IterableTable,
+  GroupedDataSelector,
+  TekGridEvents,
+  DataNavigator,
+  TableActionBuilder,
+  ColumnsSearcher,
+  GroupedDataManager,
+  TekGridToolbarProvider,
+  GroupedViewNavigator,
+  DataEditorWithAdd,
+} from '../../../../src';
+import { createComponent, findComponent, setClick, spyOnAllMethods } from '../../__helpers__';
+
+jest.mock('lodash.debounce', () => jest.fn((fn) => fn));
+
+jest.useFakeTimers();
+
+const createAtom = <T extends ComponentRender>(name: keyof ITekGridAtoms, componentClass: Newable<T>, instance: TekGrid): T => {
+  const buttonName = instance.getAtomName(name);
+  const buttonProps = findComponent(buttonName, instance.toolbarSlot)
+  return createComponent(componentClass, buttonProps);
+}
+
+const createAtomAndClick = <T extends ComponentRender>(name: keyof ITekGridAtoms, componentClass: Newable<T>, instance: TekGrid): T => {
+  const button = createAtom(name, componentClass, instance);
+  const event = {
+    defaultPrevented: false,
+    preventDefault() {
+      this.defaultPrevented = true;
+    }
+  };
+  setClick(button, event);
+
+  return button;
+}
+
+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('TekGrid', () => {
+  beforeAll(() => {
+    // mock Loader
+    Loader.setBuilder(new SimpleControllerBuilder());
+  })
+
+  beforeEach(() => {
+    // clear all metadata instances before testing
+    const { instances } = Metadata as any;
+    Object.keys(instances).forEach((key) => {
+      Metadata.clearInstance(key, instances[key].componentId);
+    });
+
+    jest.clearAllTimers();
+  });
+
+  describe('constructor()', () => {
+    it('should create new grid with default values', () => {
+      const instance = new TekGrid({ name: 'Grid', component: 'TekGrid' });
+      expect(instance.title).toBe('');
+      expect(instance.addButton).toBeFalsy();
+      expect(instance.deleteButton).toBe('none');
+      expect(instance.filterButton).toBeFalsy();
+      expect(instance.modalFilterProps).toEqual(
+        expect.objectContaining({
+          height: 'auto',
+          persistent: true,
+        }),
+      );
+      expect(instance.columnFilterButton).toBeFalsy();
+      expect(instance.dragColumns).toBeTruthy();
+      expect(instance.resizeColumns).toBeTruthy();
+      expect(instance.showLayoutOptions).toBeTruthy();
+      expect(instance.showSearch).toBeTruthy();
+      expect(instance.showSummaryTotal).toBeTruthy();
+      expect(instance.showReload).toBeTruthy();
+      expect(instance.columnsButton).toBeFalsy();
+      expect(instance.columnsButtonIgnore).toEqual([]);
+    });
+
+    it('should create new Grid replacing default values', () => {
+      const instance = new TekGrid({
+        name: 'grid',
+        component: 'TekGrid',
+        title: 'title',
+        addButton: true,
+        deleteButton: 'selection',
+        filterButton: true,
+        modalFilterProps: {
+          name: 'teste',
+          height: 'auto',
+          persistent: false,
+          cssClass: 'class-test',
+          cssStyle: 'background: red',
+          draggable: true,
+          fullscreen: true,
+          light: false,
+          dark: true,
+        },
+        columnFilterButton: true,
+        dragColumns: false,
+        resizeColumns: false,
+        showLayoutOptions: false,
+        showSearch: false,
+        showSummaryTotal: false,
+        showReload: false,
+        columns: [
+          { name: 'id' },
+        ],
+        columnsButton: true,
+        columnsButtonIgnore: ['id'],
+      });
+      expect(instance.title).toBe('title');
+      expect(instance.addButton).toBeTruthy();
+      expect(instance.deleteButton).toBe('selection');
+      expect(instance.filterButton).toBeTruthy();
+      expect(instance.modalFilterProps).toEqual(
+        expect.objectContaining({
+          height: 'auto',
+          persistent: false,
+        }),
+      );
+      expect(instance.columnFilterButton).toBeTruthy();
+      expect(instance.dragColumns).toBeFalsy();
+      expect(instance.resizeColumns).toBeFalsy();
+      expect(instance.showLayoutOptions).toBeFalsy();
+      expect(instance.showSearch).toBeFalsy();
+      expect(instance.showSummaryTotal).toBeFalsy();
+      expect(instance.showReload).toBeFalsy();
+      expect(instance.columns[0]).toBeInstanceOf(TekGridColumn);
+      expect(instance.columnsButton).toBeTruthy();
+      expect(instance.columnsButtonIgnore).toEqual(['id']);
+    });
+
+    it('should create toolbar and footer', () => {
+      const instance = new TekGrid({
+        name: 'grid',
+        component: 'TekGrid',
+        title: 'title',
+        addButton: true,
+        deleteButton: 'selection',
+        filterButton: true,
+        columnFilterButton: true,
+        dragColumns: false,
+        resizeColumns: false,
+        showLayoutOptions: false,
+      });
+      instance.onCreated();
+      expect(instance.toolbarSlot.length).toBe(4);
+    });
+
+    it('should overwrite toolbar', () => {
+      const instance = new TekGrid({
+        name: 'grid',
+        component: 'TekGrid',
+        title: 'title',
+        addButton: true,
+        deleteButton: 'selection',
+        filterButton: true,
+        columnFilterButton: true,
+        dragColumns: false,
+        resizeColumns: false,
+        showLayoutOptions: false,
+        toolbarSlot: [],
+      });
+      instance.onCreated();
+      expect(instance.toolbarSlot.length).toBe(0);
+    });
+
+    it('should create new TekGrid with accessor datasource', () => {
+      const spy = jest.spyOn(Loader, 'getInstance').mockImplementation(() => {
+        return {
+          datasource: {
+            uniqueKey: 'id',
+            data: [{ id: '1' }],
+          },
+        };
+      });
+      const instance = new TekGrid({
+        name: 'grid',
+        component: 'TekGrid',
+        datasource: '{{AppController.datasource}}' as any,
+      });
+      instance.onCreated();
+
+      expect(instance.datasource).toBeInstanceOf(Datasource);
+      expect(instance.datasource.data).toEqual([{ id: '1' }]);
+
+      spy.mockRestore();
+    });
+
+    it('should create a new grid with defined values', () => {
+      const instance = new TekGrid({
+        name: 'grid',
+        component: 'TekGrid',
+        doubleClickEdit: true,
+        backgroundColor: 'blue',
+      });
+
+      expect(instance.name).toBe('grid');
+      expect(instance.doubleClickEdit).toBeTruthy();
+      expect(instance.backgroundColor).toBe('blue');
+    });
+  });
+
+  describe('saveChanges()', () => {
+    it('should call saveEditedRows', () => {
+      const instance = new TekGrid({
+        name: 'grid_saveChanges1',
+        component: 'TekGrid',
+      });
+
+      const spy = jest.spyOn(instance, 'saveEditedRows');
+      instance.onCreated();
+
+      const button = createAtomAndClick('SAVE_BUTTON', Button, instance);
+
+      expect(spy).toHaveBeenCalled();
+      expect(button.isVisible).toBeFalsy();
+      spy.mockReset();
+    });
+
+    it('should call events', () => {
+      let beforeSaveCalled = false;
+      let afterSaveCalled = false;
+      const instance = new TekGrid({
+        name: 'grid_saveChanges2',
+        component: 'TekGrid',
+        events: {
+          beforeSave: () => { beforeSaveCalled = true; },
+          afterSave: () => { afterSaveCalled = true; },
+        },
+      });
+
+      instance.onCreated();
+
+      createAtomAndClick('SAVE_BUTTON', Button, instance);
+
+      expect(beforeSaveCalled).toBeTruthy();
+      expect(afterSaveCalled).toBeTruthy();
+    });
+
+    it('should not call saveEditedRows if beforeSave call preventDefault', () => {
+      const beforeSaveMock = jest.fn().mockImplementation(({ event }) => { event.defaultPrevented = true });
+      const afterSaveMock = jest.fn();
+
+      const instance = new TekGrid({
+        name: 'grid_saveChanges3',
+        component: 'TekGrid',
+        events: {
+          beforeSave: beforeSaveMock,
+          afterSave: afterSaveMock,
+        },
+      });
+
+      const spy = jest.spyOn(instance, 'saveEditedRows');
+      instance.onCreated();
+
+      createAtomAndClick('SAVE_BUTTON', Button, instance);
+
+      expect(beforeSaveMock).toHaveBeenCalled();
+      expect(afterSaveMock).not.toHaveBeenCalled();
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockReset();
+    });
+  });
+
+  describe('cancelChanges()', () => {
+    it('should call cancelEditedRows', () => {
+      const instance = new TekGrid({
+        name: 'grid_cancelChanges1',
+        component: 'TekGrid',
+      });
+
+      const spy = jest.spyOn(instance, 'cancelEditedRows');
+      instance.onCreated();
+
+      const button = createAtomAndClick('CANCEL_BUTTON', Button, instance);
+
+      expect(spy).toHaveBeenCalled();
+      expect(button.isVisible).toBeFalsy();
+      spy.mockReset();
+    });
+
+    it('should call events', () => {
+      let beforeCancelCalled = false;
+      let afterCancelCalled = false;
+      const instance = new TekGrid({
+        name: 'grid_cancelChanges2',
+        component: 'TekGrid',
+        events: {
+          beforeCancel: () => { beforeCancelCalled = true; },
+          afterCancel: () => { afterCancelCalled = true; },
+        },
+      });
+
+      instance.onCreated();
+
+      createAtomAndClick('CANCEL_BUTTON', Button, instance);
+
+      expect(beforeCancelCalled).toBeTruthy();
+      expect(afterCancelCalled).toBeTruthy();
+    });
+
+    it('should not call cancelEditedRows if beforeSave call preventDefault', () => {
+      const beforeCancelMock = jest.fn().mockImplementation(({ event }) => { event.defaultPrevented = true });
+      const afterCancelMock = jest.fn();
+      const instance = new TekGrid({
+        name: 'grid_cancelChanges3',
+        component: 'TekGrid',
+        events: {
+          beforeCancel: beforeCancelMock,
+          afterCancel: afterCancelMock,
+        },
+      });
+
+      const spy = jest.spyOn(instance, 'cancelEditedRows');
+      instance.onCreated();
+
+      createAtomAndClick('CANCEL_BUTTON', Button, instance);
+
+      expect(beforeCancelMock).toHaveBeenCalled();
+      expect(afterCancelMock).not.toHaveBeenCalled();
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockReset();
+    });
+  });
+
+  describe('addButtonClick()', () => {
+    it('should call event', () => {
+      const instance = new TekGrid({
+        name: 'grid_addClick1',
+        component: 'TekGrid',
+        addButton: true,
+        editNewRowsOnly: true,
+      });
+
+      instance.onCreated();
+
+      const button = createAtomAndClick('ADD_BUTTON', Button, instance);
+
+      const addClickSpy = jest.fn();
+      instance.events = {
+        addClick: addClickSpy,
+      };
+
+      expect(instance.editingNewRows).toBeTruthy();
+
+      setClick(button)
+
+      expect(addClickSpy).toHaveBeenCalled();
+      expect(button.isVisible).toBeTruthy();
+    });
+  });
+
+  describe('hideButtonClick()', () => {
+    it('should hide toolbar', () => {
+      const instance = new TekGrid({
+        name: 'grid_deleteClick2',
+        component: 'TekGrid',
+      });
+
+      instance.onCreated();
+
+      const toolbarMock = { isVisible: true };
+      jest.spyOn(Metadata, 'getInstance').mockImplementation(() => toolbarMock);
+
+      expect(toolbarMock.isVisible).toBeTruthy();
+
+      createAtomAndClick('HIDE_BUTTON', Button, instance);
+
+      expect(toolbarMock.isVisible).toBeFalsy();
+    });
+
+    it('should show toolbar', () => {
+      const instance = new TekGrid({
+        name: 'grid_deleteClick2',
+        component: 'TekGrid',
+        toolbarOpened: false,
+      });
+
+      instance.onCreated();
+
+      const toolbarMock = { isVisible: true };
+      jest.spyOn(Metadata, 'getInstance').mockImplementation(() => toolbarMock);
+
+      const button = createAtomAndClick('HIDE_BUTTON', Button, instance);
+
+      expect(toolbarMock.isVisible).toBeFalsy();
+
+      setClick(button);
+
+      expect(toolbarMock.isVisible).toBeTruthy();
+    });
+  });
+
+  describe('deleteButtonClick()', () => {
+    it('should call deleteRows', () => {
+      const instance = new TekGrid({
+        name: 'grid_deleteButtonClick1',
+        component: 'TekGrid',
+        deleteButton: 'currentRow',
+      });
+
+      const spy = jest.spyOn(instance, 'deleteRows');
+      instance.onCreated();
+
+      const button = createAtomAndClick('DELETE_BUTTON', Button, instance);
+      expect(spy).toHaveBeenCalled();
+      expect(button.isVisible).toBeTruthy();
+      expect(button.disabled).toBeTruthy();
+      spy.mockReset();
+    });
+
+    it('should call events', () => {
+      let beforeDeleteCalled = false;
+      let afterDeleteCalled = false;
+      const instance = new TekGrid({
+        name: 'grid_deleteClick2',
+        component: 'TekGrid',
+        events: {
+          beforeDelete: () => { beforeDeleteCalled = true; },
+          afterDelete: () => { afterDeleteCalled = true; },
+        },
+      });
+
+      instance.onCreated();
+      createAtomAndClick('DELETE_BUTTON', Button, instance);
+      expect(beforeDeleteCalled).toBeTruthy();
+      expect(afterDeleteCalled).toBeTruthy();
+    });
+
+    it('should not call afterDelete if beforeDelete call preventDefault', () => {
+      const beforeDeleteMock = jest.fn().mockImplementation(({ event }) => { event.defaultPrevented = true });
+      const afterDeleteMock = jest.fn();
+      const instance = new TekGrid({
+        name: 'grid_deleteClick3',
+        component: 'TekGrid',
+        events: {
+          beforeDelete: beforeDeleteMock,
+          afterDelete: afterDeleteMock,
+        },
+      });
+
+      const spy = jest.spyOn(instance, 'cancelEditedRows');
+      instance.onCreated();
+
+      createAtomAndClick('DELETE_BUTTON', Button, instance);
+
+      expect(beforeDeleteMock).toHaveBeenCalled();
+      expect(afterDeleteMock).not.toHaveBeenCalled();
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockReset();
+    });
+
+    it('when deleteButton is clicked with selectAllPages, should throw', () => {
+      const instance = new TekGrid({
+        name: 'grid_deleteButtonClick1',
+        component: 'TekGrid',
+        deleteButton: 'selection',
+        selectAllPages: true,
+        datasource: {
+          data: [{ id: '1' }],
+        },
+      });
+
+      instance.onCreated();
+
+      const button = createAtom('DELETE_BUTTON', Button, instance);
+
+      expect(button.isVisible).toBeTruthy();
+      expect(button.disabled).toBeTruthy();
+
+      instance.selectAll(true);
+
+      expect(button.disabled).toBeFalsy();
+      expect(() => setClick(button)).toThrow();
+    });
+  });
+
+  describe('disableDeleteButton', () => {
+    it('should not disable deleteButton when deleteButton equals none', () => {
+      const instance = new TekGrid({
+        name: 'grid_deleteButtonClick1',
+        component: 'TekGrid',
+        deleteButton: 'none',
+      });
+
+      instance.onCreated();
+      const button = createAtom('DELETE_BUTTON', Button, instance);
+      expect(button.isVisible).toBeFalsy();
+      expect(button.disabled).toBeFalsy();
+    });
+  });
+
+  describe('getConditionalProps', () => {
+    it('should return an empty object when no conditions are applied', () => {
+      const grid = setupInstance();
+      const row = grid.datasource.data[0];
+      const column = grid.columns[0];
+      const result = grid.getConditionalProps({ row, column });
+      expect(result).toEqual({});
+    });
+
+    it('should merge row style conditions and cell applied conditions', () => {
+      const grid = setupInstance();
+      grid.getRowStyleConditions = jest.fn().mockReturnValue({ backgroundColor: 'red' });
+      grid.getAppliedConditions = jest.fn().mockReturnValue({ fontSize: '12px' });
+      const row = grid.datasource.data[0];
+      const column = grid.columns[0];
+      const result = grid.getConditionalProps({ row, column });
+      expect(result).toEqual({ backgroundColor: 'red', fontSize: '12px' });
+    });
+  });
+
+  describe('onCreated()', () => {
+    it('should call DynamicFilterDatasourceFactory to create dynamic filter datasources', () => {
+      const spy = jest.spyOn(DynamicFilterDatasourceFactory.prototype, 'factory');
+      setupInstance({ name: 'grid', component: 'TekGrid', datasource: { type: 'tek-memory' } });
+
+      expect(spy).toHaveBeenCalled();
+      spy.mockReset();
+    });
+  });
+
+  describe('onMounted()', () => {
+    it('should call KeyMapMerger bind', () => {
+      const spy = jest.spyOn(KeyMapMerger.prototype, 'bind');
+      const instance = setupInstance({ name: 'grid', component: 'TekGrid' });
+      instance.onMounted({} as HTMLElement);
+
+      expect(spy).toHaveBeenCalled();
+      spy.mockReset();
+    });
+  });
+
+  describe('onBeforeDestroy()', () => {
+    it('should call KeyMapMerger unbind', () => {
+      const spy = jest.spyOn(KeyMapMerger.prototype, 'unbind');
+      const instance = setupInstance({ name: 'grid', component: 'TekGrid' });
+      instance.onMounted({} as HTMLElement);
+      instance.onBeforeDestroy();
+
+      expect(spy).toHaveBeenCalled();
+      spy.mockReset();
+    });
+  });
+
+  describe('columnHasFilter()', () => {
+    it('should return true if column has filter', () => {
+      const datasourceMock = { hasFilter: jest.fn(() => true) };
+      const instance = new TekGrid({ name: 'grid', component: 'TekGrid' });
+      instance.datasource = datasourceMock as any as Datasource;
+
+      expect(instance.columnHasFilter('test')).toBeTruthy();
+    });
+  });
+
+  describe('TekGrid Delegations', () => {
+    const mockProps = {
+      name: 'test-grid',
+      component: 'ZdGrid',
+    };
+  
+    it('should call IterableTable delegation methods', () => {
+      const spyObj = spyOnAllMethods(IterableTable.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.changeOrder([{ key: 'name', order: 'asc' }]);
+      expect(spyObj.changeOrder).toHaveBeenCalledWith([{ key: 'name', order: 'asc' }]);
+
+      instance.selectCell({ id: 1 }, { name: 'test' } as any);
+      expect(spyObj.selectCell).toHaveBeenCalledWith({ id: 1 }, { name: 'test' });
+
+      instance.reapplyRowStyleConditions({ id: 1 });
+      expect(spyObj.reapplyRowStyleConditions).toHaveBeenCalledWith({ id: 1 });
+
+      instance.getRowStyleConditions({ id: 1 });
+      expect(spyObj.getRowStyleConditions).toHaveBeenCalledWith({ id: 1 });
+
+      instance.deleteRows();
+      expect(spyObj.deleteRows).toHaveBeenCalled();
+    });
+  
+    it('should call GroupedDataSelector delegation methods', () => {
+      const spyObj = spyOnAllMethods(GroupedDataSelector.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.selectAll(true);
+      expect(spyObj.selectAll).toHaveBeenCalledWith(true);
+
+      instance.toggleRow({ id: 1 });
+      expect(spyObj.toggleRow).toHaveBeenCalledWith({ id: 1 });
+
+      instance.selectRow({ id: 1 }, true);
+      expect(spyObj.selectRow).toHaveBeenCalledWith({ id: 1 }, true);
+
+      instance.callDisableSelection({ id: 1 });
+      expect(spyObj.callDisableSelection).toHaveBeenCalledWith({ id: 1 });
+
+      instance.selectClick({ id: 1 }, true, {} as Event);
+      expect(spyObj.selectClick).toHaveBeenCalledWith({ id: 1 }, true, {}, undefined);
+
+      instance.selectAllClick(true, {} as Event);
+      expect(spyObj.selectAllClick).toHaveBeenCalledWith(true, {}, undefined);
+    });
+
+    it('should call TekGridEvents delegation methods', () => {
+      const spyObj = spyOnAllMethods(TekGridEvents.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.calcSummary({ name: 'test' } as any, {} as any, { id: 1 });
+      expect(spyObj.calcSummary).toHaveBeenCalledWith({ name: 'test' }, {}, { id: 1 });
+
+      instance.rowClick({ id: 1 }, {} as Event);
+      expect(spyObj.rowClick).toHaveBeenCalledWith({ id: 1 }, {}, undefined);
+
+      instance.rowDoubleClick({ id: 1 }, {} as Event);
+      expect(spyObj.rowDoubleClick).toHaveBeenCalledWith({ id: 1 }, {}, undefined);
+
+      instance.cellDoubleClick({ id: 1 }, { name: 'test' } as any, {} as Event);
+      expect(spyObj.cellDoubleClick).toHaveBeenCalledWith({ id: 1 }, { name: 'test' }, {}, undefined);
+
+      instance.inlineEdit({ id: 1 }, { name: 'test' } as any);
+      expect(spyObj.inlineEdit).toHaveBeenCalledWith({ id: 1 }, { name: 'test' }, undefined, undefined);
+
+      instance.cellClick({ id: 1 }, { name: 'test' } as any, {} as Event);
+      expect(spyObj.cellClick).toHaveBeenCalledWith({ id: 1 }, { name: 'test' }, {}, undefined);
+
+      instance.cellClickEvent({ id: 1 }, { name: 'test' } as any, {} as Event);
+      expect(spyObj.cellClickEvent).toHaveBeenCalledWith({ id: 1 }, { name: 'test' }, {}, undefined);
+
+      instance.groupRowClick({ id: 1 }, {} as Event);
+      expect(spyObj.groupRowClick).toHaveBeenCalledWith({ id: 1 }, {}, undefined);
+
+      instance.groupRowDoubleClick({ id: 1 }, {} as Event);
+      expect(spyObj.groupRowDoubleClick).toHaveBeenCalledWith({ id: 1 }, {}, undefined);
+
+      instance.selectGroupClick({ id: 1 }, true, {} as Event);
+      expect(spyObj.selectGroupClick).toHaveBeenCalledWith({ id: 1 }, true, {}, undefined);
+    });
+
+    it('should call DataNavigator delegation methods', () => {
+      const spyObj = spyOnAllMethods(DataNavigator.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.navigatePageUp();
+      expect(spyObj.navigatePageUp).toHaveBeenCalled();
+
+      instance.navigatePageDown();
+      expect(spyObj.navigatePageDown).toHaveBeenCalled();
+
+      instance.navigateDatasource('up');
+      expect(spyObj.navigateDatasource).toHaveBeenCalledWith('up');
+    });
+
+    it('should call GroupedViewNavigator delegation methods', () => {
+      const spyObj = spyOnAllMethods(GroupedViewNavigator.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.setViewNavigate(() => {});
+      expect(spyObj.setViewNavigate).toHaveBeenCalled();
+
+      instance.navigateLeft({} as any);
+      expect(spyObj.navigateLeft).not.toHaveBeenCalledWith({});
+
+      instance.navigateRight({} as any);
+      expect(spyObj.navigateRight).not.toHaveBeenCalledWith({});
+
+      instance.cellSelection = true;
+
+      instance.navigateLeft({} as any);
+      expect(spyObj.navigateLeft).toHaveBeenCalledWith({});
+
+      instance.navigateRight({} as any);
+      expect(spyObj.navigateRight).toHaveBeenCalledWith({});
+
+      instance.navigateUp();
+      expect(spyObj.navigateUp).toHaveBeenCalled();
+
+      instance.navigateDown();
+      expect(spyObj.navigateDown).toHaveBeenCalled();
+    });
+
+    it('should call DataEditorWithAdd delegation methods', () => {
+      const spyObj = spyOnAllMethods(DataEditorWithAdd.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.addCancelColumn();
+      expect(spyObj.addCancelColumn).toHaveBeenCalled();
+
+      instance.getCancelColumnProps();
+      expect(spyObj.getCancelColumnProps).toHaveBeenCalled();
+
+      instance.isAdded({ id: 1 });
+      expect(spyObj.isAdded).toHaveBeenCalledWith({ id: 1 });
+
+      instance.cancelAddedRow('1');
+      expect(spyObj.cancelAddedRow).toHaveBeenCalledWith('1');
+
+      instance.cancelAddedRows();
+      expect(spyObj.cancelAddedRows).toHaveBeenCalled();
+
+      instance.getAddedRows();
+      expect(spyObj.getAddedRows).toHaveBeenCalled();
+
+      instance.addNewRow({ id: 1 });
+      expect(spyObj.addNewRow).toHaveBeenCalledWith({ id: 1 }, undefined);
+
+      instance.getVisibleValue({ id: 1 }, { name: 'test' } as any);
+      expect(spyObj.getVisibleValue).toHaveBeenCalledWith({ id: 1 }, { name: 'test' });
+
+      instance.getEditableComponent({ name: 'test' } as any, { id: 1 });
+      expect(spyObj.getEditableComponent).toHaveBeenCalledWith({ name: 'test' }, { id: 1 });
+
+      instance.isEdited({ name: 'test' } as any, { id: 1 });
+      expect(spyObj.isEdited).toHaveBeenCalledWith({ name: 'test' }, { id: 1 });
+
+      instance.isValid({ name: 'test' } as any, { id: 1 });
+      expect(spyObj.isValid).toHaveBeenCalledWith({ name: 'test' }, { id: 1 }, undefined);
+
+      instance.isGridValid();
+      expect(spyObj.isGridValid).toHaveBeenCalled();
+
+      instance.getComponent('1', 'name');
+      expect(spyObj.getComponent).toHaveBeenCalledWith('1', 'name');
+
+      instance.updateRow({ id: 1 });
+      expect(spyObj.updateRow).toHaveBeenCalledWith({ id: 1 });
+
+      instance.updateCell('1', 'name', 'value');
+      expect(spyObj.updateCell).toHaveBeenCalledWith('1', 'name', 'value');
+
+      instance.setViewEnterEdit(() => {});
+      expect(spyObj.setViewEnterEdit).toHaveBeenCalled();
+
+      instance.enterEdit('1', 'name');
+      expect(spyObj.enterEdit).toHaveBeenCalledWith('1', 'name');
+
+      instance.cancelEditedRows();
+      expect(spyObj.cancelEditedRows).toHaveBeenCalled();
+
+      instance.saveEditedRows();
+      expect(spyObj.saveEditedRows).toHaveBeenCalled();
+
+      instance.reapplyCanEditRow({ id: 1 });
+      expect(spyObj.reapplyCanEditRow).toHaveBeenCalledWith({ id: 1 });
+
+      instance.getCanEditRow({ id: 1 });
+      expect(spyObj.getCanEditRow).toHaveBeenCalledWith({ id: 1 });
+
+      instance.getEditedRows();
+      expect(spyObj.getEditedRows).toHaveBeenCalled();
+
+      instance.checkValid({ name: 'test' } as any, { id: 1 });
+      expect(spyObj.checkValid).toHaveBeenCalledWith({ name: 'test' }, { id: 1 });
+
+      instance.getEditedRow({ id: 1 });
+      expect(spyObj.getEditedRow).toHaveBeenCalledWith({ id: 1 });
+    });
+
+    it('should call TableActionBuilder delegation methods', () => {
+      const spyObj = spyOnAllMethods(TableActionBuilder.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.getActionComponent({} as any, { name: 'test' } as any, { id: 1 });
+      expect(spyObj.getActionComponent).toHaveBeenCalledWith({}, { name: 'test' }, { id: 1 }, undefined);
+    });
+
+    it('should call GroupedDataManager delegation methods', () => {
+      const spyObj = spyOnAllMethods(GroupedDataManager.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.registerTask(Promise.resolve());
+      expect(spyObj.registerTask).toHaveBeenCalled();
+
+      instance.loadAfterTasks();
+      expect(spyObj.loadAfterTasks).toHaveBeenCalled();
+
+      instance.initializeGrouping(true);
+      expect(spyObj.initializeGrouping).toHaveBeenCalledWith(true);
+
+      instance.updateGrouping();
+      expect(spyObj.updateGrouping).toHaveBeenCalled();
+
+      instance.updateGroupedData(true);
+      expect(spyObj.updateGroupedData).toHaveBeenCalledWith(true);
+
+      instance.buildGroupedData();
+      expect(spyObj.buildGroupedData).toHaveBeenCalled();
+
+      instance.openGroup({ group: true });
+      expect(spyObj.openGroup).toHaveBeenCalledWith({ group: true });
+
+      instance.isItemVisible({ id: 1 });
+      expect(spyObj.isItemVisible).toHaveBeenCalledWith({ id: 1 });
+
+      instance.isGrouped();
+      expect(spyObj.isGrouped).toHaveBeenCalled();
+
+      instance.isColumnSearchable({ name: 'test' } as any);
+      expect(spyObj.isColumnSearchable).toHaveBeenCalledWith({ name: 'test' });
+
+      instance.getGroupedData();
+      expect(spyObj.getGroupedData).toHaveBeenCalled();
+
+      instance.directionalLeft({} as any);
+      expect(spyObj.directionalLeft).toHaveBeenCalledWith({});
+
+      instance.directionalRight({} as any);
+      expect(spyObj.directionalRight).toHaveBeenCalledWith({});
+
+      instance.setViewUpdateFixedColumns(() => {});
+      expect(spyObj.setViewUpdateFixedColumns).toHaveBeenCalled();
+
+      instance.setViewUpdateScrollData(() => {});
+      expect(spyObj.setViewUpdateScrollData).toHaveBeenCalled();
+    });
+
+    it('should call TekGridToolbarProvider delegation methods', () => {
+      const spyObj = spyOnAllMethods(TekGridToolbarProvider.prototype);
+      const instance = new TekGrid(mockProps);
+
+      instance.getAtomInstance('TITLE');
+      expect(spyObj.getAtomInstance).toHaveBeenCalledWith('TITLE');
+
+      instance.getAtomName('TITLE');
+      expect(spyObj.getAtomName).toHaveBeenCalledWith('TITLE');
+    });
+
+    it('should call ColumnsSearcher delegation methods', () => {
+      const spyObj = spyOnAllMethods(ColumnsSearcher.prototype);
+      const instance = new TekGrid(mockProps);
+      instance.datasource = new TekRestDatasource({ lazyLoad: false });
+
+      instance.setSearch('test');
+      expect(spyObj.searchColumn).toHaveBeenCalled();
+
+      spyObj.searchColumn.mockClear();
+
+      instance.datasource = new TekMemoryDatasource({ lazyLoad: false });
+
+      instance.setSearch('test');
+      expect(spyObj.searchColumn).toHaveBeenCalled();
+    });
+  });
+});