feat(tests): add few Extensions unit tests

Author: Ghislain Beaulac

src/app/modules/angular-slickgrid/extensions/__tests__/autoTooltipExtension.spec.ts

@@ -0,0 +1,73 @@
+import { I18N } from 'aurelia-i18n';
+import { GridOption } from '../../models/gridOption.interface';
+import { AutoTooltipExtension } from '../autoTooltipExtension';
+import { ExtensionUtility } from '../extensionUtility';
+import { SharedService } from '../../services/shared.service';
+
+declare var Slick: any;
+
+const gridStub = {
+  getOptions: jest.fn(),
+  registerPlugin: jest.fn(),
+};
+
+const mockAddon = jest.fn().mockImplementation(() => ({
+  init: jest.fn(),
+  destroy: jest.fn()
+}));
+
+jest.mock('slickgrid/plugins/slick.autotooltips', () => mockAddon);
+Slick.AutoTooltips = mockAddon;
+
+describe('autoTooltipExtension', () => {
+  let extension: AutoTooltipExtension;
+  let extensionUtility: ExtensionUtility;
+  let sharedService: SharedService;
+  const gridOptionsMock = { enableAutoTooltip: true } as GridOption;
+
+  beforeEach(() => {
+    extensionUtility = new ExtensionUtility({} as I18N, sharedService);
+    sharedService = new SharedService();
+    extension = new AutoTooltipExtension(extensionUtility, sharedService);
+  });
+
+  it('should return null when either the grid object or the grid options is missing', () => {
+    const output = extension.register();
+    expect(output).toBeNull();
+  });
+
+  describe('registered addon', () => {
+    beforeEach(() => {
+      jest.spyOn(SharedService.prototype, 'grid', 'get').mockReturnValue(gridStub);
+      jest.spyOn(SharedService.prototype, 'gridOptions', 'get').mockReturnValue(gridOptionsMock);
+    });
+
+    it('should register the addon', () => {
+      const pluginSpy = jest.spyOn(SharedService.prototype.grid, 'registerPlugin');
+
+      const instance = extension.register();
+
+      expect(mockAddon).toHaveBeenCalledWith({});
+      expect(pluginSpy).toHaveBeenCalledWith(instance);
+    });
+
+    it('should dispose of the addon', () => {
+      const instance = extension.register();
+      const destroySpy = jest.spyOn(instance, 'destroy');
+
+      extension.dispose();
+
+      expect(destroySpy).toHaveBeenCalled();
+    });
+
+    it('should provide addon options and expect them to be called in the addon constructor', () => {
+      const optionMock = { enableForCells: true, enableForHeaderCells: false, maxToolTipLength: 12 };
+      const addonOptions = { ...gridOptionsMock, autoTooltipOptions: optionMock };
+      jest.spyOn(SharedService.prototype, 'gridOptions', 'get').mockReturnValue(addonOptions);
+
+      extension.register();
+
+      expect(mockAddon).toHaveBeenCalledWith(optionMock);
+    });
+  });
+});

src/app/modules/angular-slickgrid/extensions/__tests__/cellExternalCopyManagerExtension.spec.ts

@@ -0,0 +1,162 @@
+import { I18N } from 'aurelia-i18n';
+import { GridOption } from '../../models/gridOption.interface';
+import { CellExternalCopyManagerExtension } from '../cellExternalCopyManagerExtension';
+import { ExtensionUtility } from '../extensionUtility';
+import { SharedService } from '../../services/shared.service';
+import { SelectedRange } from '../../models';
+
+declare var Slick: any;
+
+const gridStub = {
+  getOptions: jest.fn(),
+  registerPlugin: jest.fn(),
+  setSelectionModel: jest.fn(),
+};
+
+const addonStub = {
+  init: jest.fn(),
+  destroy: jest.fn(),
+  onCopyCells: new Slick.Event(),
+  onCopyCancelled: new Slick.Event(),
+  onPasteCells: new Slick.Event(),
+};
+const mockAddon = jest.fn().mockImplementation(() => addonStub);
+const mockSelectionModel = jest.fn().mockImplementation(() => ({
+  init: jest.fn(),
+  destroy: jest.fn()
+}));
+
+jest.mock('slickgrid/plugins/slick.cellexternalcopymanager', () => mockAddon);
+Slick.CellExternalCopyManager = mockAddon;
+
+jest.mock('slickgrid/plugins/slick.cellselectionmodel', () => mockSelectionModel);
+Slick.CellSelectionModel = mockSelectionModel;
+
+describe('cellExternalCopyManagerExtension', () => {
+  const mockEventCallback = (e, args: { ranges: SelectedRange[] }) => { };
+  const mockSelectRange = [{ fromCell: 1, fromRow: 1, toCell: 1, toRow: 1 }] as SelectedRange[];
+  const mockSelectRangeEvent = { ranges: mockSelectRange };
+
+  let extension: CellExternalCopyManagerExtension;
+  let extensionUtility: ExtensionUtility;
+  let sharedService: SharedService;
+  const gridOptionsMock = {
+    enableCheckboxSelector: true,
+    excelCopyBufferOptions: {
+      onExtensionRegistered: jest.fn(),
+      onCopyCells: mockEventCallback,
+      onCopyCancelled: mockEventCallback,
+      onPasteCells: mockEventCallback,
+    }
+  } as GridOption;
+
+  beforeEach(() => {
+    extensionUtility = new ExtensionUtility({} as I18N, sharedService);
+    sharedService = new SharedService();
+    extension = new CellExternalCopyManagerExtension(extensionUtility, sharedService);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return null when either the grid object or the grid options is missing', () => {
+    const output = extension.register();
+    expect(output).toBeNull();
+  });
+
+  describe('registered addon', () => {
+    beforeEach(() => {
+      jest.spyOn(SharedService.prototype, 'grid', 'get').mockReturnValue(gridStub);
+      jest.spyOn(SharedService.prototype, 'gridOptions', 'get').mockReturnValue(gridOptionsMock);
+    });
+
+    it('should register the addon', () => {
+      const pluginSpy = jest.spyOn(SharedService.prototype.grid, 'registerPlugin');
+      const optionSpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onExtensionRegistered');
+
+      const instance = extension.register();
+
+      expect(optionSpy).toHaveBeenCalledWith(instance);
+      expect(pluginSpy).toHaveBeenCalledWith(instance);
+      expect(mockSelectionModel).toHaveBeenCalled();
+      expect(mockAddon).toHaveBeenCalledWith({
+        clipboardCommandHandler: expect.anything(),
+        dataItemColumnValueExtractor: expect.anything(),
+        newRowCreator: expect.anything(),
+        includeHeaderWhenCopying: false,
+        readOnlyMode: false,
+        onCopyCancelled: expect.anything(),
+        onCopyCells: expect.anything(),
+        onExtensionRegistered: expect.anything(),
+        onPasteCells: expect.anything(),
+      });
+    });
+
+    it('should call internal event handler subscribe and expect the "onCopyCells" option to be called when addon notify is called', () => {
+      const handlerSpy = jest.spyOn(extension.eventHandler, 'subscribe');
+      const onCopySpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onCopyCells');
+      const onCancelSpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onCopyCancelled');
+      const onPasteSpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onPasteCells');
+
+      const instance = extension.register();
+      instance.onCopyCells.notify(mockSelectRangeEvent, new Slick.EventData(), gridStub);
+
+      expect(handlerSpy).toHaveBeenCalledTimes(3);
+      expect(handlerSpy).toHaveBeenCalledWith(
+        { notify: expect.anything(), subscribe: expect.anything(), unsubscribe: expect.anything(), },
+        expect.anything()
+      );
+      expect(onCopySpy).toHaveBeenCalledWith(expect.anything(), mockSelectRangeEvent);
+      expect(onCancelSpy).not.toHaveBeenCalled();
+      expect(onPasteSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call internal event handler subscribe and expect the "onCopyCancelled" option to be called when addon notify is called', () => {
+      const handlerSpy = jest.spyOn(extension.eventHandler, 'subscribe');
+      const onCopySpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onCopyCells');
+      const onCancelSpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onCopyCancelled');
+      const onPasteSpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onPasteCells');
+
+      const instance = extension.register();
+      instance.onCopyCancelled.notify(mockSelectRangeEvent, new Slick.EventData(), gridStub);
+
+      expect(handlerSpy).toHaveBeenCalledTimes(3);
+      expect(handlerSpy).toHaveBeenCalledWith(
+        { notify: expect.anything(), subscribe: expect.anything(), unsubscribe: expect.anything(), },
+        expect.anything()
+      );
+      expect(onCopySpy).not.toHaveBeenCalled();
+      expect(onCancelSpy).toHaveBeenCalledWith(expect.anything(), mockSelectRangeEvent);
+      expect(onPasteSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call internal event handler subscribe and expect the "onPasteCells" option to be called when addon notify is called', () => {
+      const handlerSpy = jest.spyOn(extension.eventHandler, 'subscribe');
+      const onCopySpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onCopyCells');
+      const onCancelSpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onCopyCancelled');
+      const onPasteSpy = jest.spyOn(SharedService.prototype.gridOptions.excelCopyBufferOptions, 'onPasteCells');
+
+      const instance = extension.register();
+      instance.onPasteCells.notify(mockSelectRangeEvent, new Slick.EventData(), gridStub);
+
+      expect(handlerSpy).toHaveBeenCalledTimes(3);
+      expect(handlerSpy).toHaveBeenCalledWith(
+        { notify: expect.anything(), subscribe: expect.anything(), unsubscribe: expect.anything(), },
+        expect.anything()
+      );
+      expect(onCopySpy).not.toHaveBeenCalled();
+      expect(onCancelSpy).not.toHaveBeenCalled();
+      expect(onPasteSpy).toHaveBeenCalledWith(expect.anything(), mockSelectRangeEvent);
+    });
+
+    it('should dispose of the addon', () => {
+      const instance = extension.register();
+      const destroySpy = jest.spyOn(instance, 'destroy');
+
+      extension.dispose();
+
+      expect(destroySpy).toHaveBeenCalled();
+    });
+  });
+});

src/app/modules/angular-slickgrid/extensions/__tests__/checkboxSelectorExtension.spec.ts

@@ -0,0 +1,144 @@
+import { I18N } from 'aurelia-i18n';
+import { GridOption } from '../../models/gridOption.interface';
+import { CheckboxSelectorExtension } from '../checkboxSelectorExtension';
+import { ExtensionUtility } from '../extensionUtility';
+import { SharedService } from '../../services/shared.service';
+import { Column } from '../../models';
+
+declare var Slick: any;
+
+const gridStub = {
+  getOptions: jest.fn(),
+  getSelectionModel: jest.fn(),
+  registerPlugin: jest.fn(),
+  setSelectionModel: jest.fn(),
+};
+
+const mockAddon = jest.fn().mockImplementation(() => ({
+  init: jest.fn(),
+  destroy: jest.fn(),
+  getColumnDefinition: jest.fn(),
+  selectRows: jest.fn(),
+}));
+const mockSelectionModel = jest.fn().mockImplementation(() => ({
+  init: jest.fn(),
+  destroy: jest.fn()
+}));
+
+jest.mock('slickgrid/plugins/slick.checkboxselectcolumn', () => mockAddon);
+Slick.CheckboxSelectColumn = mockAddon;
+
+jest.mock('slickgrid/plugins/slick.rowselectionmodel', () => mockSelectionModel);
+Slick.RowSelectionModel = mockSelectionModel;
+
+describe('checkboxSelectorExtension', () => {
+  let extension: CheckboxSelectorExtension;
+  let extensionUtility: ExtensionUtility;
+  let sharedService: SharedService;
+  const gridOptionsMock = { enableCheckboxSelector: true } as GridOption;
+
+  beforeEach(() => {
+    extensionUtility = new ExtensionUtility({} as I18N, sharedService);
+    sharedService = new SharedService();
+    extension = new CheckboxSelectorExtension(extensionUtility, sharedService);
+  });
+
+  it('should return null after calling "create" method when either the column definitions or the grid options is missing', () => {
+    const output = extension.create([] as Column[], null);
+    expect(output).toBeNull();
+  });
+
+  it('should return null after calling "register" method when either the grid object or the grid options is missing', () => {
+    const output = extension.register();
+    expect(output).toBeNull();
+  });
+
+  describe('registered addon', () => {
+    let columnSelectionMock: Column;
+    let columnsMock: Column[];
+
+    beforeEach(() => {
+      columnsMock = [{ id: 'field1', field: 'field1', width: 100, cssClass: 'red' }];
+      columnSelectionMock = { id: '_checkbox_selector', field: 'sel' };
+      jest.spyOn(SharedService.prototype, 'grid', 'get').mockReturnValue(gridStub);
+      jest.spyOn(SharedService.prototype, 'gridOptions', 'get').mockReturnValue(gridOptionsMock);
+    });
+
+    it('should register the addon', () => {
+      const pluginSpy = jest.spyOn(SharedService.prototype.grid, 'registerPlugin');
+
+      const instance = extension.create(columnsMock, gridOptionsMock);
+      const selectionModel = extension.register();
+
+      expect(selectionModel).not.toBeNull();
+      expect(mockAddon).toHaveBeenCalledWith({});
+      expect(mockSelectionModel).toHaveBeenCalledWith({});
+      expect(pluginSpy).toHaveBeenCalledWith(instance);
+    });
+
+    it('should register the addon with the registered plugin provided as argument', () => {
+      const pluginSpy = jest.spyOn(SharedService.prototype.grid, 'registerPlugin');
+      const selectionSpy = jest.spyOn(SharedService.prototype.grid, 'getSelectionModel');
+
+      const instance = extension.create(columnsMock, gridOptionsMock);
+      const selectionModel = extension.register();
+      const selectionModel2 = extension.register(selectionModel);
+
+      expect(selectionModel).not.toBeNull();
+      expect(selectionModel2).not.toBeNull();
+      expect(mockAddon).toHaveBeenCalledWith({});
+      expect(selectionSpy).toHaveBeenCalled();
+      expect(mockSelectionModel).toHaveBeenCalledWith({});
+      expect(pluginSpy).toHaveBeenCalledWith(instance);
+    });
+
+    it('should dispose of the addon', () => {
+      const instance = extension.create(columnsMock, gridOptionsMock);
+      const destroySpy = jest.spyOn(instance, 'destroy');
+
+      extension.dispose();
+
+      expect(destroySpy).toHaveBeenCalled();
+    });
+
+    it('should provide addon options and expect them to be called in the addon constructor', () => {
+      const optionMock = { selectActiveRow: true };
+      const selectionModelOptions = { ...gridOptionsMock, rowSelectionOptions: optionMock };
+      const selectionColumn = { ...columnSelectionMock, excludeFromExport: true, excludeFromColumnPicker: true, excludeFromGridMenu: true, excludeFromQuery: true, excludeFromHeaderMenu: true };
+      jest.spyOn(SharedService.prototype, 'gridOptions', 'get').mockReturnValue(selectionModelOptions);
+
+      // we can only spy after 1st "create" call, we'll only get a valid selectionColumn on 2nd "create" call
+      const instance = extension.create(columnsMock, gridOptionsMock);
+      jest.spyOn(instance, 'getColumnDefinition').mockReturnValue(columnSelectionMock);
+      expect(columnsMock[0]).not.toEqual(selectionColumn);
+
+      // do our expect here after 2nd "create" call, the selectionColumn flags will change only after this 2nd call
+      extension.create(columnsMock, gridOptionsMock);
+      extension.register();
+
+      expect(mockSelectionModel).toHaveBeenCalledWith(optionMock);
+      expect(columnsMock[0]).toEqual(selectionColumn);
+    });
+
+    it('should be able to pre-select rows', (done) => {
+      const selectionModelOptions = { ...gridOptionsMock, preselectedRows: [0], rowSelectionOptions: { selectActiveRow: true } };
+      jest.spyOn(SharedService.prototype, 'gridOptions', 'get').mockReturnValue(selectionModelOptions);
+      const pluginSpy = jest.spyOn(SharedService.prototype.grid, 'registerPlugin');
+      const selectionSpy = jest.spyOn(SharedService.prototype.grid, 'getSelectionModel').mockReturnValue(true);
+
+      const instance = extension.create(columnsMock, gridOptionsMock);
+      const rowSpy = jest.spyOn(instance, 'selectRows');
+      const selectionModel = extension.register();
+
+      expect(selectionModel).not.toBeNull();
+      expect(mockAddon).toHaveBeenCalledWith({});
+      expect(selectionSpy).toHaveBeenCalled();
+      expect(mockSelectionModel).toHaveBeenCalledWith({});
+      expect(pluginSpy).toHaveBeenCalledWith(instance);
+      setTimeout(() => {
+        expect(rowSpy).toHaveBeenCalledWith(selectionModelOptions.preselectedRows);
+        done();
+      });
+    });
+  });
+});