@sb1/ffe-tables-react 8.0.35 → 8.0.37

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -11,7 +11,8 @@ var __assign = (this && this.__assign) || function () {
11
11
  };
12
12
  import React from 'react';
13
13
  import Table from './DefaultTable';
14
- import TableRowExpandable from '../TableParts/TableRowExpandable';
14
+ import { fireEvent, render, screen, within } from '@testing-library/react';
15
+ import { expect } from '@playwright/test';
15
16
  describe('<Table />', function () {
16
17
  var columns = [
17
18
  { key: 'name', header: 'Navn' },
@@ -43,99 +44,109 @@ describe('<Table />', function () {
43
44
  phone: '+45 018 456 789',
44
45
  },
45
46
  ];
46
- var wrapperWithoutOverride = mount(React.createElement(Table, { columns: columnsWithFooterContent, data: data }));
47
+ /* const wrapperWithoutOverride = mount(
48
+ <Table columns={columnsWithFooterContent} data={data} />,
49
+ );
50
+ */
47
51
  describe('general', function () {
48
- it('renders without exploding', function () {
49
- var wrapper = shallow(React.createElement(Table, { columns: columns, data: data }));
50
- expect(wrapper).toHaveLength(1);
51
- });
52
52
  it('renders the correct dom structure', function () {
53
- var wrapper = shallow(React.createElement(Table, { columns: columns, data: data }));
54
- expect(wrapper.is('table')).toBe(true);
55
- expect(wrapper.hasClass('ffe-table')).toBe(true);
56
- expect(wrapper.hasClass('ffe-table--condensed')).toBe(false);
53
+ render(React.createElement(Table, { columns: columns, data: data }));
54
+ var table = screen.getByRole('table');
55
+ expect(table.classList.contains('ffe-table')).toBe(true);
56
+ expect(table.classList.contains('ffe-table--condensed')).toBe(false);
57
57
  });
58
58
  it('can be condensed', function () {
59
- var wrapper = shallow(React.createElement(Table, { condensed: true, columns: columns, data: data }));
60
- expect(wrapper.hasClass('ffe-table')).toBe(true);
61
- expect(wrapper.hasClass('ffe-table--condensed')).toBe(true);
59
+ render(React.createElement(Table, { columns: columns, data: data, condensed: true }));
60
+ var table = screen.getByRole('table');
61
+ expect(table.classList.contains('ffe-table')).toBe(true);
62
+ expect(table.classList.contains('ffe-table--condensed')).toBe(true);
62
63
  });
63
64
  it('can be left aligned', function () {
64
- var wrapper = shallow(React.createElement(Table, { alignLeft: true, columns: columns, data: data }));
65
- expect(wrapper.hasClass('ffe-table')).toBe(true);
66
- expect(wrapper.hasClass('ffe-table--text-left')).toBe(true);
65
+ render(React.createElement(Table, { columns: columns, data: data, alignLeft: true }));
66
+ var table = screen.getByRole('table');
67
+ expect(table.classList.contains('ffe-table')).toBe(true);
68
+ expect(table.classList.contains('ffe-table--text-left')).toBe(true);
67
69
  });
68
70
  it('can have a two column layout on mobile', function () {
69
- var wrapper = shallow(React.createElement(Table, { columnLayoutMobile: true, columns: columns, data: data }));
70
- expect(wrapper.hasClass('ffe-table')).toBe(true);
71
- expect(wrapper.hasClass('ffe-table--columns-sm')).toBe(true);
71
+ render(React.createElement(Table, { columnLayoutMobile: true, columns: columns, data: data }));
72
+ var table = screen.getByRole('table');
73
+ expect(table.classList.contains('ffe-table')).toBe(true);
74
+ expect(table.classList.contains('ffe-table--columns-sm')).toBe(true);
72
75
  });
73
76
  it('applies supplied classes', function () {
74
- var wrapper = shallow(React.createElement(Table, { columns: columns, data: data, className: "test-class-one test-class-two" }));
75
- expect(wrapper.hasClass('ffe-table')).toBe(true);
76
- expect(wrapper.hasClass('test-class-one')).toBe(true);
77
- expect(wrapper.hasClass('test-class-two')).toBe(true);
77
+ render(React.createElement(Table, { columns: columns, data: data, className: "test-class-one test-class-two" }));
78
+ var table = screen.getByRole('table');
79
+ expect(table.classList.contains('ffe-table')).toBe(true);
80
+ expect(table.classList.contains('test-class-one')).toBe(true);
81
+ expect(table.classList.contains('test-class-two')).toBe(true);
78
82
  });
79
83
  });
80
84
  describe('table caption', function () {
81
85
  it('does not render a <caption /> if caption prop is not provided', function () {
82
- var wrapper = shallow(React.createElement(Table, { columns: columns, data: data }));
83
- expect(wrapper.find('caption')).toHaveLength(0);
86
+ var container = render(React.createElement(Table, { columns: columns, data: data })).container;
87
+ expect(container.querySelector('caption')).toBeFalsy();
84
88
  });
85
89
  it('renders a <caption /> if caption prop is provided', function () {
86
- var wrapper = shallow(React.createElement(Table, { columns: columns, data: data, caption: "A nice table" }));
87
- expect(wrapper.find('caption')).toHaveLength(1);
88
- expect(wrapper.find('caption').text()).toBe('A nice table');
90
+ var container = render(React.createElement(Table, { columns: columns, data: data, caption: "A nice table" })).container;
91
+ expect(container.querySelector('caption').textContent).toBe('A nice table');
89
92
  });
90
93
  });
91
94
  describe('table headers', function () {
92
- var wrapper = render(React.createElement(Table, { columns: columns, data: data }));
93
95
  it('renders columns inside a <thead />', function () {
94
- expect(wrapper.find('thead')).toHaveLength(1);
96
+ render(React.createElement(Table, { columns: columns, data: data }));
97
+ var thead = screen.getAllByRole('rowgroup')[0];
98
+ expect(thead.tagName).toBe('THEAD');
95
99
  });
96
100
  it('renders columns as <th /> tags', function () {
97
- expect(wrapper.find('th')).toHaveLength(3);
101
+ render(React.createElement(Table, { columns: columns, data: data }));
102
+ var thead = screen.getAllByRole('rowgroup')[0];
103
+ expect(within(thead).getAllByRole('columnheader')).toHaveLength(3);
98
104
  });
99
105
  it('renders header content as <th /> content', function () {
100
- expect(wrapper.find('th').first().text()).toBe(columns[0].header);
106
+ render(React.createElement(Table, { columns: columns, data: data }));
107
+ var first = screen.getAllByRole('columnheader')[0];
108
+ expect(first.textContent).toBe(columns[0].header);
101
109
  });
102
110
  });
103
111
  describe('table footer', function () {
104
- var wrapper = render(React.createElement(Table, { columns: columnsWithFooterContent, data: data }));
105
112
  it('renders a <tfoot />', function () {
106
- expect(wrapper.find('tfoot')).toHaveLength(1);
113
+ render(React.createElement(Table, { columns: columnsWithFooterContent, data: data }));
114
+ var _a = screen.getAllByRole('rowgroup'), tfoot = _a[1];
115
+ expect(tfoot.tagName).toBe('TFOOT');
107
116
  });
108
117
  it('renders the footer content inside <tfoot />', function () {
109
- expect(wrapper.find('tfoot').find('td').first().text()).toBe('Sum alder');
118
+ render(React.createElement(Table, { columns: columnsWithFooterContent, data: data }));
119
+ var _a = screen.getAllByRole('rowgroup'), tfoot = _a[1];
120
+ var firstColumn = within(tfoot).getAllByRole('cell')[0];
121
+ expect(firstColumn.textContent).toBe('Sum alder');
110
122
  });
111
123
  it('does not render <tfoot /> unless footer is present in columns', function () {
112
- var wrapperWithoutFooterContent = render(React.createElement(Table, { columns: columns, data: data }));
113
- expect(wrapperWithoutFooterContent.find('tfoot')).toHaveLength(0);
124
+ render(React.createElement(Table, { columns: columns, data: data }));
125
+ var _a = screen.getAllByRole('rowgroup'), tfoot = _a[2];
126
+ expect(tfoot).toBeFalsy();
114
127
  });
115
128
  });
116
129
  describe('table footer override', function () {
117
- var wrapper;
130
+ var container;
131
+ var rerender;
118
132
  var mockCallback;
119
133
  var columnsForFooterRender = [
120
134
  { key: 'name', header: 'Navn', footer: 'Sum alder' },
121
135
  {
122
136
  key: 'address',
123
137
  header: 'Adresse',
124
- columnFooterRender: function (value, dataWindow, tdProps, spanProps, headerColumns, index) {
138
+ columnFooterRender: function (value, dataWindow, tdProps, spanProps) {
125
139
  return (React.createElement("td", __assign({}, tdProps),
126
140
  React.createElement("span", __assign({}, spanProps), value)));
127
141
  },
128
142
  },
129
143
  { key: 'age', header: 'Alder', footer: 135, alignRight: true },
130
144
  ];
131
- var wrapperWithDefaultOverride = (wrapper = mount(React.createElement(Table, { columns: columnsForFooterRender, data: data, footerRender: function (trProps, columnsFooter) {
132
- return React.createElement("tr", __assign({}, trProps));
133
- } })));
134
145
  beforeEach(function () {
135
146
  mockCallback = jest.fn();
136
147
  });
137
148
  beforeEach(function () {
138
- wrapper = mount(React.createElement(Table, { columns: columnsForFooterRender, data: data, footerRender: function (trProps, columnsFooter) {
149
+ var _a = render(React.createElement(Table, { columns: columnsForFooterRender, data: data, footerRender: function (trProps, columnsFooter) {
139
150
  return (React.createElement(React.Fragment, null,
140
151
  React.createElement("tr", __assign({}, trProps, { "data-abc": "aaa123", onClick: function (event) {
141
152
  mockCallback();
@@ -146,50 +157,42 @@ describe('<Table />', function () {
146
157
  trProps.children[0],
147
158
  trProps.children[1],
148
159
  trProps.children[2])));
149
- } }));
150
- });
151
- it('renders a <tfoot /> tr has custom props', function () {
152
- var propKeyProp = wrapper.find('tfoot tr').first().props();
153
- expect(propKeyProp).toHaveProperty('data-abc', 'aaa123');
154
- expect(wrapper.find('tfoot tr').first().render().attr('data-abc')).toBe('aaa123');
160
+ } })), _container = _a.container, _rerender = _a.rerender;
161
+ container = _container;
162
+ rerender = _rerender;
155
163
  });
156
164
  it('renders a <tfoot />, triggers tr onClick method', function () {
157
- wrapper.find('tfoot tr').first().simulate('click');
165
+ fireEvent.click(container.querySelectorAll('tfoot tr')[0]);
158
166
  expect(mockCallback.mock.calls.length).toBe(1);
159
167
  });
160
168
  it('renders a <tfoot /> that has two identical rows, the second row has array notation', function () {
161
- var tr0html = wrapper.find('tfoot tr').at(0).html();
162
- var tr1html = wrapper.find('tfoot tr').at(1).html();
163
- expect(tr1html).toBe(tr0html);
169
+ var _a = container.querySelectorAll('tfoot tr'), tr0html = _a[0], tr1html = _a[1];
170
+ expect(tr1html.innerHTML).toBe(tr0html.innerHTML);
164
171
  });
165
172
  it('renders a <tfoot /> with override that should look like the default', function () {
166
- var withoutOverrideHtml = wrapperWithoutOverride
167
- .find('tfoot')
168
- .first()
169
- .html();
170
- var withDefaultOverrideHtml = wrapperWithDefaultOverride
171
- .find('tfoot')
172
- .first()
173
- .html();
173
+ rerender(React.createElement(Table, { columns: columnsWithFooterContent, data: data }));
174
+ var withoutOverrideHtml = container.querySelectorAll('tfoot')[0].innerHTML;
175
+ rerender(React.createElement(Table, { columns: columnsForFooterRender, data: data, footerRender: function (trProps, columnsFooter) {
176
+ return React.createElement("tr", __assign({}, trProps));
177
+ } }));
178
+ var withDefaultOverrideHtml = container.querySelectorAll('tfoot')[0].innerHTML;
174
179
  expect(withDefaultOverrideHtml).toBe(withoutOverrideHtml);
175
180
  });
176
181
  });
177
182
  describe('table header override', function () {
178
- var wrapper;
183
+ var container;
184
+ var rerender;
179
185
  var mockCallback;
180
186
  var columnsForFooterRender = [
181
187
  { key: 'name', header: 'Navn', footer: 'Navn' },
182
188
  { key: 'address', header: 'Adresse' },
183
189
  { key: 'age', header: 'Alder', footer: 135, alignRight: true },
184
190
  ];
185
- var wrapperWithDefaultOverride = (wrapper = mount(React.createElement(Table, { columns: columnsForFooterRender, data: data, headerRender: function (trProps, headerColumns) {
186
- return React.createElement("tr", __assign({}, trProps));
187
- } })));
188
191
  beforeEach(function () {
189
192
  mockCallback = jest.fn();
190
193
  });
191
194
  beforeEach(function () {
192
- wrapper = mount(React.createElement(Table, { columns: columnsForFooterRender, data: data, headerRender: function (trProps, headerColumns) {
195
+ var _a = render(React.createElement(Table, { columns: columnsForFooterRender, data: data, headerRender: function (trProps, headerColumns) {
193
196
  return (React.createElement(React.Fragment, null,
194
197
  React.createElement("tr", __assign({}, trProps, { "data-abc": "aaa123", onClick: function (event) {
195
198
  mockCallback();
@@ -200,58 +203,53 @@ describe('<Table />', function () {
200
203
  trProps.children[0],
201
204
  trProps.children[1],
202
205
  trProps.children[2])));
203
- } }));
204
- });
205
- it('renders a <thead /> tr has custom props', function () {
206
- var propKeyProp = wrapper.find('thead tr').first().props();
207
- expect(propKeyProp).toHaveProperty('data-abc', 'aaa123');
208
- expect(wrapper.find('thead tr').first().render().attr('data-abc')).toBe('aaa123');
206
+ } })), _container = _a.container, _rerender = _a.rerender;
207
+ container = _container;
208
+ rerender = _rerender;
209
209
  });
210
210
  it('renders a <thead />, triggers tr onClick method', function () {
211
- wrapper.find('thead').find('tr').first().simulate('click');
211
+ fireEvent.click(container.querySelectorAll('thead tr')[0]);
212
212
  expect(mockCallback.mock.calls.length).toBe(1);
213
213
  });
214
214
  it('renders a <thead /> that has two identical rows, the second row has array notation', function () {
215
- var tr0html = wrapper.find('thead').find('tr').at(0).html();
216
- var tr1html = wrapper.find('thead').find('tr').at(1).html();
217
- expect(tr1html).toBe(tr0html);
215
+ var _a = container.querySelectorAll('thead tr'), tr0html = _a[0], tr1html = _a[1];
216
+ expect(tr1html.innerHTML).toBe(tr0html.innerHTML);
218
217
  });
219
218
  it('renders a <thead /> with override that should look like the default', function () {
220
- var withoutOverrideHtml = wrapperWithoutOverride
221
- .find('thead')
222
- .first()
223
- .html();
224
- var withDefaultOverrideHtml = wrapperWithDefaultOverride
225
- .find('thead')
226
- .first()
227
- .html();
219
+ rerender(React.createElement(Table, { columns: columnsWithFooterContent, data: data }));
220
+ var withoutOverrideHtml = container.querySelectorAll('thead')[0].innerHTML;
221
+ rerender(React.createElement(Table, { columns: columnsForFooterRender, data: data, headerRender: function (trProps, headerColumns) {
222
+ return React.createElement("tr", __assign({}, trProps));
223
+ } }));
224
+ var withDefaultOverrideHtml = container.querySelectorAll('thead')[0].innerHTML;
228
225
  expect(withDefaultOverrideHtml).toBe(withoutOverrideHtml);
229
226
  });
230
227
  });
231
228
  describe('expandable table rows', function () {
232
- var wrapper = mount(React.createElement(Table, { columns: [
233
- { key: 'name', header: 'Navn' },
234
- { key: 'address', header: 'Adresse' },
235
- ], data: [
236
- {
237
- name: 'First',
238
- address: 'Expand me',
239
- },
240
- {
241
- name: 'Second',
242
- },
243
- ], expandedContentMapper: function (row) {
244
- return row.address && (React.createElement("span", { className: "expandedcontent" },
245
- "Adresse: ",
246
- row.address));
247
- } }));
248
229
  it('should render expandable rows when if expandable content is available', function () {
249
- expect(wrapper.find('tbody').length).toBe(2);
250
- expect(wrapper.find(TableRowExpandable).length).toBe(1);
230
+ var container = render(React.createElement(Table, { columns: [
231
+ { key: 'name', header: 'Navn' },
232
+ { key: 'address', header: 'Adresse' },
233
+ ], data: [
234
+ {
235
+ name: 'First',
236
+ address: 'Expand me',
237
+ },
238
+ {
239
+ name: 'Second',
240
+ },
241
+ ], expandedContentMapper: function (row) {
242
+ return row.address && (React.createElement("span", { className: "expandedcontent" },
243
+ "Adresse: ",
244
+ row.address));
245
+ } })).container;
246
+ expect(container.querySelectorAll('tbody').length).toBe(2);
247
+ expect(container.querySelectorAll('.ffe-table__row-expandable').length).toBe(1);
251
248
  });
252
249
  });
253
250
  describe('table row render override', function () {
254
- var wrapper;
251
+ var container;
252
+ var rerender;
255
253
  var mockCallback;
256
254
  var columnsForRenderOverride = [
257
255
  {
@@ -270,126 +268,98 @@ describe('<Table />', function () {
270
268
  "Adresse: ",
271
269
  row.address));
272
270
  };
273
- var wrapperWithDefaultOverride = (wrapper = mount(React.createElement(Table, { columns: columnsForRenderOverride, data: data, rowRender: function (trprops, props, rowIndex) {
274
- return React.createElement("tr", __assign({}, trprops));
275
- } })));
276
- var wrapperWithExendedRowAndRenderOverride = (wrapper = mount(React.createElement(Table, { columns: columnsForRenderOverride, data: data, expandedContentMapper: expandedContentMapper, rowRender: function (trprops, props, rowIndex) {
277
- return (React.createElement("tr", __assign({}, trprops, { onClick: function (event) {
278
- mockCallback();
279
- trprops.onClick(event);
280
- } })));
281
- } })));
282
271
  beforeEach(function () {
283
272
  mockCallback = jest.fn();
284
273
  });
285
274
  beforeEach(function () {
286
- wrapper = mount(React.createElement(Table, { columns: columnsForRenderOverride, data: data, rowRender: function (trprops, props, rowIndex) {
275
+ var _a = render(React.createElement(Table, { columns: columnsForRenderOverride, data: data, rowRender: function (trprops, props, rowIndex) {
287
276
  return (React.createElement("tr", __assign({}, trprops, { "data-my-prop": "12345", onClick: function (event) {
288
277
  mockCallback();
289
278
  } })));
290
- } }));
291
- });
292
- it('renders a <tbody /> tr has custom props', function () {
293
- var propKeyProp = wrapper
294
- .find('tbody')
295
- .find('tr')
296
- .first()
297
- .props();
298
- expect(propKeyProp).toHaveProperty('data-my-prop', '12345');
299
- expect(wrapper.find('tbody tr').first().render().attr('data-my-prop')).toBe('12345');
279
+ } })), _container = _a.container, _rerender = _a.rerender;
280
+ container = _container;
281
+ rerender = _rerender;
300
282
  });
301
283
  it('renders a <tbody />, triggers tr onClick method', function () {
302
- wrapper.find('tbody').find('tr').first().simulate('click');
284
+ fireEvent.click(container.querySelectorAll('tbody tr')[0]);
303
285
  expect(mockCallback.mock.calls.length).toBe(1);
304
286
  });
305
287
  it('renders a <tbody /> with extendedRow, triggers tr onClick method', function () {
306
- wrapperWithExendedRowAndRenderOverride
307
- .find('tbody')
308
- .first()
309
- .find('tr')
310
- .first()
311
- .simulate('click');
312
- expect(wrapperWithExendedRowAndRenderOverride
313
- .find('tbody')
314
- .first()
315
- .find('.ffe-table__row-expandable-content--expanded')
316
- .length).toBe(1);
288
+ rerender(React.createElement(Table, { columns: columnsForRenderOverride, data: data, expandedContentMapper: expandedContentMapper, rowRender: function (trprops, props, rowIndex) {
289
+ return (React.createElement("tr", __assign({}, trprops, { onClick: function (event) {
290
+ mockCallback();
291
+ trprops.onClick(event);
292
+ } })));
293
+ } }));
294
+ var tbody = container.querySelectorAll('tbody')[0];
295
+ fireEvent.click(tbody.querySelectorAll('tr')[0]);
296
+ expect(Array.from(tbody.querySelectorAll('.ffe-table__row-expandable-content--expanded')).length).toBe(1);
317
297
  expect(mockCallback.mock.calls.length).toBe(1);
318
- wrapperWithExendedRowAndRenderOverride
319
- .find('tbody')
320
- .first()
321
- .find('tr')
322
- .first()
323
- .simulate('click');
324
- expect(wrapperWithExendedRowAndRenderOverride
325
- .find('tbody')
326
- .first()
327
- .find('.ffe-table__row-expandable-content--expanded')
328
- .length).toBe(0);
298
+ fireEvent.click(tbody.querySelectorAll('tr')[0]);
299
+ expect(Array.from(tbody.querySelectorAll('.ffe-table__row-expandable-content--expanded')).length).toBe(0);
329
300
  });
330
301
  it('renders a <tbody /> with override that should look like the default', function () {
331
- var withoutOverrideHtml = wrapperWithoutOverride
332
- .find('tbody')
333
- .first()
334
- .html();
335
- var withDefaultOverrideHtml = wrapperWithDefaultOverride
336
- .find('tbody')
337
- .first()
338
- .html();
302
+ rerender(React.createElement(Table, { columns: columnsWithFooterContent, data: data }));
303
+ var withoutOverrideHtml = container.querySelectorAll('tbody')[0].innerHTML;
304
+ rerender(React.createElement(Table, { columns: columnsForRenderOverride, data: data, footerRender: function (trProps, columnsFooter) {
305
+ return React.createElement("tr", __assign({}, trProps));
306
+ } }));
307
+ var withDefaultOverrideHtml = container.querySelectorAll('tbody')[0].innerHTML;
339
308
  expect(withDefaultOverrideHtml).toBe(withoutOverrideHtml);
340
309
  });
341
310
  });
342
311
  describe('table body', function () {
343
312
  it('does not render a tbody if data prop is empty', function () {
344
- var wrapper = shallow(React.createElement(Table, { columns: columns, data: [] }));
345
- expect(wrapper.find('tbody')).toHaveLength(0);
313
+ var container = render(React.createElement(Table, { columns: columns, data: [] })).container;
314
+ expect(container.querySelectorAll('tbody')).toHaveLength(0);
346
315
  });
347
316
  it('renders a tbody if data is provided', function () {
348
- var wrapper = shallow(React.createElement(Table, { columns: columns, data: data }));
349
- expect(wrapper.find('tbody')).toHaveLength(1);
317
+ var container = render(React.createElement(Table, { columns: columns, data: data })).container;
318
+ expect(container.querySelectorAll('tbody')).toHaveLength(1);
350
319
  });
351
320
  it('renders a <tr /> row for each entry in the data prop', function () {
352
- var wrapper = render(React.createElement(Table, { columns: columns, data: data }));
353
- expect(wrapper.find('tbody tr')).toHaveLength(data.length);
321
+ var container = render(React.createElement(Table, { columns: columns, data: data })).container;
322
+ expect(container.querySelectorAll('tbody tr')).toHaveLength(data.length);
354
323
  });
355
324
  it('renders a <td /> cell for each entry in each row', function () {
356
- var wrapper = render(React.createElement(Table, { columns: columns, data: data }));
357
- expect(wrapper.find('td')).toHaveLength(data.length * columns.length);
325
+ var container = render(React.createElement(Table, { columns: columns, data: data })).container;
326
+ expect(container.querySelectorAll('td')).toHaveLength(data.length * columns.length);
358
327
  });
359
328
  it('renders a content-div inside each td', function () {
360
- var wrapper = render(React.createElement(Table, { columns: columns, data: data }));
361
- expect(wrapper.find('td .ffe-table__content').length).toBe(data.length * columns.length);
329
+ var container = render(React.createElement(Table, { columns: columns, data: data })).container;
330
+ expect(container.querySelectorAll('td .ffe-table__content').length).toBe(data.length * columns.length);
362
331
  });
363
332
  it('renders content of each cell', function () {
364
- var wrapper = render(React.createElement(Table, { columns: columns, data: data }));
365
- expect(wrapper.find('td .ffe-table__content').first().text()).toBe(data[0].name);
333
+ var container = render(React.createElement(Table, { columns: columns, data: data })).container;
334
+ expect(container.querySelectorAll('td .ffe-table__content')[0]
335
+ .textContent).toBe(data[0].name);
366
336
  });
367
337
  it('adds column heading to data-th property of each cell', function () {
368
- var wrapper = render(React.createElement(Table, { data: data, columns: columns }));
369
- expect(wrapper.find('[data-th="Navn"]')).toHaveLength(columns.length);
370
- expect(wrapper.find('td').first().prop('data-th')).toBe(columns[0].header);
338
+ var container = render(React.createElement(Table, { data: data, columns: columns })).container;
339
+ expect(container.querySelectorAll('[data-th="Navn"]')).toHaveLength(columns.length);
371
340
  });
372
341
  it('render screen reader only caption', function () {
373
- var wrapper = render(React.createElement(Table, { data: data, columns: columns, caption: "Read me", srOnlyCaption: true }));
374
- expect(wrapper.find('caption')).toHaveLength(1);
375
- expect(wrapper.find('caption').hasClass('ffe-screenreader-only')).toBe(true);
376
- expect(wrapper.find('caption').text()).toBe('Read me');
342
+ var container = render(React.createElement(Table, { data: data, columns: columns, caption: "Read me", srOnlyCaption: true })).container;
343
+ var captions = container.querySelectorAll('caption');
344
+ expect(captions).toHaveLength(1);
345
+ expect(captions[0].classList.contains('ffe-screenreader-only')).toBe(true);
346
+ expect(captions[0].textContent).toBe('Read me');
377
347
  });
378
348
  it('do not render caption when srOnlyCaption is true but missing caption text', function () {
379
- var wrapper = render(React.createElement(Table, { data: data, columns: columns, srOnlyCaption: true }));
380
- expect(wrapper.find('caption')).toHaveLength(0);
349
+ var container = render(React.createElement(Table, { data: data, columns: columns, srOnlyCaption: true })).container;
350
+ expect(container.querySelectorAll('caption')).toHaveLength(0);
381
351
  });
382
352
  it('sets correct class for top-alignment on table cells', function () {
383
353
  var columnsWithTopAlignment = columns.map(function (column) { return (__assign(__assign({}, column), { alignTop: true })); });
384
- var wrapper = render(React.createElement(Table, { data: data, columns: columnsWithTopAlignment }));
385
- expect(wrapper.find('.ffe-table__cell--top').length).toBe(9);
354
+ var container = render(React.createElement(Table, { data: data, columns: columnsWithTopAlignment })).container;
355
+ expect(container.querySelectorAll('.ffe-table__cell--top').length).toBe(9);
386
356
  });
387
357
  it('sets correct class for hiding column on desktop', function () {
388
358
  var columnsWithTopAlignment = columns.map(function (column, index) {
389
359
  return index === 0 ? __assign(__assign({}, column), { hideOnDesktop: true }) : column;
390
360
  });
391
- var wrapper = render(React.createElement(Table, { data: data, columns: columnsWithTopAlignment }));
392
- expect(wrapper.find('.ffe-table--hide-xlg').length).toBe(4);
361
+ var container = render(React.createElement(Table, { data: data, columns: columnsWithTopAlignment })).container;
362
+ expect(container.querySelectorAll('.ffe-table--hide-xlg').length).toBe(4);
393
363
  });
394
364
  });
395
365
  describe('offset and limit properties', function () {
@@ -398,43 +368,46 @@ describe('<Table />', function () {
398
368
  address: "Sesame Street ".concat(i),
399
369
  age: i,
400
370
  }); });
401
- var getContentOfFirstColumn = function (comp) {
402
- return comp.find('.ffe-table__cell:first-of-type .ffe-table__content');
403
- };
404
371
  describe('setting limit', function () {
405
- var contentOfFirstColumn = getContentOfFirstColumn(render(React.createElement(Table, { columns: columns, data: muchData, limit: 3 })));
406
372
  it('reduces number of table rows', function () {
407
- return expect(contentOfFirstColumn).toHaveLength(3);
373
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, limit: 3 })).container;
374
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')).toHaveLength(3);
408
375
  });
409
376
  it('does not skip data', function () {
410
- return expect(contentOfFirstColumn.first().text()).toBe('A');
377
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, limit: 3 })).container;
378
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')[0].textContent).toBe('A');
411
379
  });
412
380
  it('limits data', function () {
413
- return expect(contentOfFirstColumn.last().text()).toBe('C');
381
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, limit: 3 })).container;
382
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')[2].textContent).toBe('C');
414
383
  });
415
384
  });
416
385
  describe('setting offset', function () {
417
- var contentOfFirstColumn = getContentOfFirstColumn(render(React.createElement(Table, { columns: columns, data: muchData, offset: 10 })));
418
386
  it('reduces number of table rows', function () {
419
- return expect(contentOfFirstColumn).toHaveLength(5);
387
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, offset: 10 })).container;
388
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')).toHaveLength(5);
420
389
  });
421
390
  it('skips data', function () {
422
- return expect(contentOfFirstColumn.first().text()).toBe('K');
391
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, offset: 10 })).container;
392
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')[0].textContent).toBe('K');
423
393
  });
424
394
  it('does not limits data', function () {
425
- return expect(contentOfFirstColumn.last().text()).toBe('O');
395
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, offset: 10 })).container;
396
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')[4].textContent).toBe('O');
426
397
  });
427
398
  });
428
399
  describe('setting both', function () {
429
- var contentOfFirstColumn = getContentOfFirstColumn(render(React.createElement(Table, { columns: columns, data: muchData, offset: 5, limit: 4 })));
430
400
  it('reduces number of table rows', function () {
431
- return expect(contentOfFirstColumn).toHaveLength(4);
401
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, offset: 5, limit: 4 })).container;
402
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')).toHaveLength(4);
432
403
  });
433
404
  it('skips data', function () {
434
- return expect(contentOfFirstColumn.first().text()).toBe('F');
405
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, offset: 5, limit: 4 })).container;
406
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')[0].textContent).toBe('F');
435
407
  });
436
408
  it('limits data', function () {
437
- return expect(contentOfFirstColumn.last().text()).toBe('I');
409
+ var container = render(React.createElement(Table, { columns: columns, data: muchData, offset: 5, limit: 4 })).container;
410
+ expect(container.querySelectorAll('.ffe-table__cell:first-of-type .ffe-table__content')[3].textContent).toBe('I');
438
411
  });
439
412
  });
440
413
  });