text: import React from 'react';
  import { spy, stub } from 'sinon';
  import { mount, shallow } from 'enzyme';
  import { assert, expect, should } from 'chai';
  import TableResize from '../src/components/TableResize';
  import MUIDataTable from '../src/MUIDataTable';
  
  describe('<TableResize />', function () {
    let options;
  
    before(() => {
      options = {
        resizableColumns: true,
        tableBodyHeight: '500px',
      };
    });
  
    it('should render a table resize component', () => {
      const updateDividers = spy();
      const setResizeable = spy();
  
      const mountWrapper = mount(
        <TableResize options={options} updateDividers={updateDividers} setResizeable={setResizeable} />,
      );
  
      const actualResult = mountWrapper.find(TableResize);
      assert.strictEqual(actualResult.length, 1);
  
      assert.strictEqual(updateDividers.callCount, 1);
      assert.strictEqual(setResizeable.callCount, 1);
    });
  
    it('should create a coordinate map for each column', () => {
      const columns = ['Name', 'Age', 'Location', 'Phone'];
      const data = [['Joe', 26, 'Chile', '555-5555']];
  
      const shallowWrapper = mount(<MUIDataTable columns={columns} data={data} options={options} />);
  
      var state = shallowWrapper.find(TableResize).childAt(0).state();
  
      var colCoordCount = 0;
      for (let prop in state.resizeCoords) {
        colCoordCount++;
      }
  
      shallowWrapper.unmount();
  
      assert.strictEqual(colCoordCount, 5);
    });
  
    it('should execute resize methods correctly', () => {
      const updateDividers = spy();
      let cellsRef = {
        0: {
          left: 0,
          width: 50,
          getBoundingClientRect: () => ({
            left: 0,
            width: 50,
            height: 100,
          }),
          style: {},
        },
        1: {
          left: 50,
          width: 50,
          getBoundingClientRect: () => ({
            left: 50,
            width: 50,
            height: 100,
          }),
          style: {},
        },
      };
      let tableRef = {
        style: {
          width: '100px',
        },
        getBoundingClientRect: () => ({
          width: 100,
          height: 100,
        }),
        offsetParent: {
          offsetLeft: 0,
        },
      };
  
      const setResizeable = (next) => {
        next(cellsRef, tableRef);
      };
  
      const shallowWrapper = shallow(
        <TableResize options={options} updateDividers={updateDividers} setResizeable={setResizeable} />,
      );
      const instance = shallowWrapper.dive().instance();
  
      instance.handleResize();
  
      let evt = {
        clientX: 48,
      };
      instance.onResizeStart(0, evt);
      instance.onResizeMove(0, evt);
      instance.onResizeEnd(0, evt);
  
      evt = {
        clientX: 52,
      };
      instance.onResizeStart(0, evt);
      instance.onResizeMove(0, evt);
      instance.onResizeEnd(0, evt);
  
      let endState = shallowWrapper.dive().state();
      //console.dir(endState);
  
      assert.strictEqual(endState.tableWidth, 100);
      assert.strictEqual(endState.tableHeight, 100);
    });
  });
  