@zeedhi/common 3.0.2 → 3.0.4

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

@@ -1,895 +0,0 @@
-/* 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();
-    });
-  });
-});