File size: 2,964 Bytes
1e92f2d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
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);
  });
});