mirror of
https://github.com/ant-design/ant-design.git
synced 2024-12-03 00:09:39 +08:00
645 lines
21 KiB
JavaScript
645 lines
21 KiB
JavaScript
/* eslint-disable import/first */
|
|
jest.mock('../../_util/scrollTo');
|
|
|
|
import React from 'react';
|
|
import Table from '..';
|
|
import { fireEvent, render, act } from '../../../tests/utils';
|
|
import scrollTo from '../../_util/scrollTo';
|
|
import { resetWarned } from '../../_util/warning';
|
|
|
|
describe('Table.pagination', () => {
|
|
const columns = [
|
|
{
|
|
title: 'Name',
|
|
dataIndex: 'name',
|
|
},
|
|
];
|
|
|
|
const data = [
|
|
{ key: 0, name: 'Jack' },
|
|
{ key: 1, name: 'Lucy' },
|
|
{ key: 2, name: 'Tom' },
|
|
{ key: 3, name: 'Jerry' },
|
|
];
|
|
|
|
const longData = [];
|
|
for (let i = 0; i < 100; i += 1) {
|
|
longData.push({ key: i, name: `${i}` });
|
|
}
|
|
|
|
const pagination = { className: 'my-page', pageSize: 2 };
|
|
|
|
function createTable(props) {
|
|
return <Table columns={columns} dataSource={data} pagination={pagination} {...props} />;
|
|
}
|
|
|
|
function renderedNames(contain) {
|
|
// --- reserve comment for code review ---
|
|
// return wrapper.find('BodyRow').map(row => row.props().record.name);
|
|
const namesList = [];
|
|
contain
|
|
.querySelector('.ant-table-tbody')
|
|
.querySelectorAll('tr')
|
|
.forEach(tr => {
|
|
namesList.push(tr.querySelector('td').textContent);
|
|
});
|
|
return namesList;
|
|
}
|
|
|
|
it('renders pagination correctly', () => {
|
|
const { asFragment } = render(createTable());
|
|
expect(asFragment().firstChild).toMatchSnapshot();
|
|
});
|
|
|
|
it('not crash when pageSize is undefined', () => {
|
|
expect(() => {
|
|
render(createTable({ pagination: { pageSize: undefined } }));
|
|
}).not.toThrow();
|
|
});
|
|
|
|
it('should not show pager if pagination.hideOnSinglePage is true and only 1 page', () => {
|
|
const { container, rerender } = render(
|
|
createTable({ pagination: { pageSize: 3, hideOnSinglePage: true } }),
|
|
);
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
rerender(createTable({ pagination: { pageSize: 3, hideOnSinglePage: false } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
rerender(createTable({ pagination: { pageSize: 4, hideOnSinglePage: true } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(0);
|
|
rerender(createTable({ pagination: { pageSize: 4, hideOnSinglePage: false } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
rerender(createTable({ pagination: { pageSize: 5, hideOnSinglePage: true } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(0);
|
|
rerender(createTable({ pagination: { pageSize: 5, hideOnSinglePage: false } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
});
|
|
|
|
it('should use pageSize when defaultPageSize and pageSize are both specified', () => {
|
|
const { container } = render(createTable({ pagination: { pageSize: 3, defaultPageSize: 4 } }));
|
|
expect(container.querySelectorAll('.ant-pagination-item')).toHaveLength(2);
|
|
});
|
|
|
|
it('paginate data', () => {
|
|
const { container } = render(createTable());
|
|
|
|
expect(renderedNames(container)).toEqual(['Jack', 'Lucy']);
|
|
fireEvent.click(container.querySelector('.ant-pagination-next'));
|
|
expect(renderedNames(container)).toEqual(['Tom', 'Jerry']);
|
|
});
|
|
|
|
it('repaginates when pageSize change', () => {
|
|
const { container, rerender } = render(createTable());
|
|
rerender(createTable({ pagination: { pageSize: 1 } }));
|
|
expect(renderedNames(container)).toEqual(['Jack']);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/33487
|
|
it('should not crash when trigger onChange in render', () => {
|
|
function App() {
|
|
const [page, setPage] = React.useState({ current: 1, pageSize: 10 });
|
|
const onChange = (current, pageSize) => {
|
|
setPage({ current, pageSize });
|
|
};
|
|
return (
|
|
<Table
|
|
dataSource={[]}
|
|
pagination={{
|
|
...page,
|
|
onChange,
|
|
}}
|
|
/>
|
|
);
|
|
}
|
|
const { asFragment } = render(<App />);
|
|
expect(asFragment().firstChild).toMatchSnapshot();
|
|
});
|
|
|
|
it('should accept pagination size', () => {
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: { size: 'small' },
|
|
}),
|
|
);
|
|
expect(container.querySelectorAll('.ant-pagination.ant-pagination-mini')).toHaveLength(1);
|
|
});
|
|
|
|
it('should scroll to first row when page change', () => {
|
|
scrollTo.mockReturnValue(null);
|
|
|
|
const { container } = render(
|
|
createTable({ scroll: { y: 20 }, pagination: { showSizeChanger: true, pageSize: 2 } }),
|
|
);
|
|
expect(scrollTo).toHaveBeenCalledTimes(0);
|
|
|
|
fireEvent.click(container.querySelector('.ant-pagination-next'));
|
|
expect(scrollTo).toHaveBeenCalledTimes(1);
|
|
|
|
fireEvent.mouseDown(container.querySelector('.ant-select-selector'));
|
|
fireEvent.click(container.querySelectorAll('.ant-select-item')[1]);
|
|
expect(scrollTo).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('should scroll inside .ant-table-body', () => {
|
|
scrollTo.mockImplementationOnce((top, { getContainer }) => {
|
|
expect(top).toBe(0);
|
|
expect(getContainer().className).toBe('ant-table-body');
|
|
});
|
|
const { container } = render(
|
|
createTable({ scroll: { y: 20 }, pagination: { showSizeChanger: true, pageSize: 2 } }),
|
|
);
|
|
fireEvent.click(container.querySelector('.ant-pagination-next'));
|
|
});
|
|
|
|
it('fires change event', () => {
|
|
const handleChange = jest.fn();
|
|
const handlePaginationChange = jest.fn();
|
|
const noop = () => {};
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: { ...pagination, onChange: handlePaginationChange, onShowSizeChange: noop },
|
|
onChange: handleChange,
|
|
}),
|
|
);
|
|
fireEvent.click(container.querySelector('.ant-pagination-next'));
|
|
|
|
expect(handleChange).toHaveBeenCalledWith(
|
|
{
|
|
className: 'my-page',
|
|
current: 2,
|
|
pageSize: 2,
|
|
},
|
|
{},
|
|
{},
|
|
{
|
|
currentDataSource: [
|
|
{ key: 0, name: 'Jack' },
|
|
{ key: 1, name: 'Lucy' },
|
|
{ key: 2, name: 'Tom' },
|
|
{ key: 3, name: 'Jerry' },
|
|
],
|
|
action: 'paginate',
|
|
},
|
|
);
|
|
|
|
expect(handlePaginationChange).toHaveBeenCalledWith(2, 2);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/4532
|
|
// https://codepen.io/afc163/pen/dVeNoP?editors=001
|
|
it('should have pager when change pagination from false to undefined', () => {
|
|
const { container, rerender } = render(createTable({ pagination: false }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(0);
|
|
|
|
rerender(createTable({ pagination: undefined }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
expect(container.querySelectorAll('.ant-pagination-item-active')).toHaveLength(1);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/4532
|
|
// https://codepen.io/afc163/pen/pWVRJV?editors=001
|
|
it('should display pagination as prop pagination change between true and false', () => {
|
|
const { container, rerender } = render(createTable());
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
expect(container.querySelectorAll('.ant-pagination-item')).toHaveLength(2);
|
|
|
|
rerender(createTable({ pagination: false }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(0);
|
|
|
|
rerender(createTable({ pagination }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
expect(container.querySelectorAll('.ant-pagination-item')).toHaveLength(2);
|
|
fireEvent.click(container.querySelector('.ant-pagination-item-2'));
|
|
expect(renderedNames(container)).toEqual(['Tom', 'Jerry']);
|
|
|
|
rerender(createTable({ pagination: false }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(0);
|
|
|
|
rerender(createTable({ pagination: undefined }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
expect(container.querySelectorAll('.ant-pagination-item')).toHaveLength(2);
|
|
expect(renderedNames(container)).toEqual(['Tom', 'Jerry']);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/5259
|
|
it('change to correct page when data source changes', () => {
|
|
const { container, rerender } = render(createTable({ pagination: { pageSize: 1 } }));
|
|
fireEvent.click(container.querySelector('.ant-pagination-item-3'));
|
|
rerender(createTable({ dataSource: [data[0]] }));
|
|
expect(
|
|
container
|
|
.querySelector('.ant-pagination-item-1')
|
|
.className.includes('ant-pagination-item-active'),
|
|
).toBe(true);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/24913
|
|
it('should called onChange when pageSize change', () => {
|
|
const onChange = jest.fn();
|
|
const onShowSizeChange = jest.fn();
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: {
|
|
current: 1,
|
|
pageSize: 10,
|
|
total: 200,
|
|
onChange,
|
|
onShowSizeChange,
|
|
},
|
|
}),
|
|
);
|
|
|
|
fireEvent.mouseDown(container.querySelector('.ant-select-selector'));
|
|
expect(container.querySelectorAll('.ant-select-item-option').length).toBe(4);
|
|
fireEvent.click(container.querySelectorAll('.ant-select-item-option')[1]);
|
|
expect(onChange).toHaveBeenCalledWith(1, 20);
|
|
});
|
|
|
|
it('should not change page when pagination current is specified', () => {
|
|
const { container } = render(createTable({ pagination: { current: 2, pageSize: 1 } }));
|
|
|
|
expect(
|
|
container
|
|
.querySelector('.ant-pagination-item-2')
|
|
.className.includes('ant-pagination-item-active'),
|
|
).toBe(true);
|
|
fireEvent.click(container.querySelector('.ant-pagination-item-3'));
|
|
expect(
|
|
container
|
|
.querySelector('.ant-pagination-item-2')
|
|
.className.includes('ant-pagination-item-active'),
|
|
).toBe(true);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/29175
|
|
it('should change page to max page count when pageSize change without pagination.total', () => {
|
|
const onChange = jest.fn();
|
|
const onShowSizeChange = jest.fn();
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: {
|
|
current: 10,
|
|
pageSize: 10,
|
|
onChange,
|
|
onShowSizeChange,
|
|
},
|
|
dataSource: longData,
|
|
}),
|
|
);
|
|
fireEvent.mouseDown(container.querySelector('.ant-select-selector'));
|
|
expect(container.querySelectorAll('.ant-select-item-option').length).toBe(4);
|
|
fireEvent.click(container.querySelectorAll('.ant-select-item-option')[1]);
|
|
const newPageSize = parseInt(
|
|
container.querySelectorAll('.ant-select-item-option')[1].textContent,
|
|
10,
|
|
);
|
|
expect(onChange).toHaveBeenCalledWith(longData.length / newPageSize, 20);
|
|
});
|
|
|
|
it('should change page to max page count when pageSize change with pagination.total', () => {
|
|
const onChange = jest.fn();
|
|
const onShowSizeChange = jest.fn();
|
|
const total = 20000;
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: {
|
|
current: total / 10,
|
|
pageSize: 10,
|
|
onChange,
|
|
total,
|
|
onShowSizeChange,
|
|
},
|
|
dataSource: longData,
|
|
}),
|
|
);
|
|
|
|
fireEvent.mouseDown(container.querySelector('.ant-select-selector'));
|
|
expect(container.querySelectorAll('.ant-select-item-option').length).toBe(4);
|
|
fireEvent.click(container.querySelectorAll('.ant-select-item-option')[1]);
|
|
const newPageSize = parseInt(
|
|
container.querySelectorAll('.ant-select-item-option')[1].textContent,
|
|
10,
|
|
);
|
|
expect(onChange).toHaveBeenCalledWith(total / newPageSize, 20);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/29175
|
|
it('should not change page to max page if current is not greater max page when pageSize change', () => {
|
|
const onChange = jest.fn();
|
|
const onShowSizeChange = jest.fn();
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: {
|
|
current: 4,
|
|
pageSize: 10,
|
|
onChange,
|
|
onShowSizeChange,
|
|
},
|
|
dataSource: longData,
|
|
}),
|
|
);
|
|
fireEvent.mouseDown(container.querySelector('.ant-select-selector'));
|
|
expect(container.querySelectorAll('.ant-select-item-option').length).toBe(4);
|
|
fireEvent.click(container.querySelectorAll('.ant-select-item-option')[1]);
|
|
expect(onChange).toHaveBeenCalledWith(4, 20);
|
|
});
|
|
|
|
it('should reset current to max page when data length is cut', () => {
|
|
const onChange = jest.fn();
|
|
const { container, rerender } = render(
|
|
createTable({
|
|
pagination: {
|
|
current: 10,
|
|
pageSize: 10,
|
|
onChange,
|
|
},
|
|
dataSource: longData,
|
|
}),
|
|
);
|
|
expect(container.querySelector('.ant-pagination-item-active').textContent).toBe('10');
|
|
rerender(
|
|
createTable({
|
|
pagination: {
|
|
current: 10,
|
|
pageSize: 10,
|
|
onChange,
|
|
},
|
|
dataSource: longData.filter(item => item.key < 60),
|
|
}),
|
|
);
|
|
|
|
expect(container.querySelector('.ant-pagination-item-active').textContent).toBe('6');
|
|
});
|
|
|
|
it('specify the position of pagination', () => {
|
|
const { container, rerender } = render(createTable({ pagination: { position: ['topLeft'] } }));
|
|
expect(container.querySelector('.ant-spin-container').children).toHaveLength(2);
|
|
expect(
|
|
container
|
|
.querySelector('.ant-spin-container')
|
|
.children[0].className.includes('ant-pagination'),
|
|
).toBe(true);
|
|
|
|
rerender(createTable({ pagination: { position: ['bottomRight'] } }));
|
|
expect(container.querySelector('.ant-spin-container').children).toHaveLength(2);
|
|
expect(
|
|
container
|
|
.querySelector('.ant-spin-container')
|
|
.children[1].className.includes('ant-pagination'),
|
|
).toBe(true);
|
|
|
|
rerender(createTable({ pagination: { position: ['topLeft', 'bottomRight'] } }));
|
|
expect(container.querySelector('.ant-spin-container').children).toHaveLength(3);
|
|
expect(
|
|
container
|
|
.querySelector('.ant-spin-container')
|
|
.children[0].className.includes('ant-pagination'),
|
|
).toBe(true);
|
|
expect(
|
|
container
|
|
.querySelector('.ant-spin-container')
|
|
.children[2].className.includes('ant-pagination'),
|
|
).toBe(true);
|
|
|
|
rerender(createTable({ pagination: { position: ['none', 'none'] } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(0);
|
|
|
|
rerender(createTable({ pagination: { position: ['invalid'] } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
|
|
rerender(createTable({ pagination: { position: ['invalid', 'invalid'] } }));
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(1);
|
|
});
|
|
|
|
/**
|
|
* `pagination` is not designed to accept `true` value, but in practice, many people assign `true`
|
|
* to `pagination`, since they misunderstand that `pagination` can accept a boolean value.
|
|
*/
|
|
it('Accepts pagination as true', () => {
|
|
const { asFragment } = render(createTable({ pagination: true }));
|
|
expect(asFragment().firstChild).toMatchSnapshot();
|
|
});
|
|
|
|
it('ajax render should keep display by the dataSource', () => {
|
|
const onChange = jest.fn();
|
|
const onPaginationChange = jest.fn();
|
|
|
|
const { container } = render(
|
|
createTable({
|
|
onChange,
|
|
pagination: {
|
|
total: 200,
|
|
onChange: onPaginationChange,
|
|
},
|
|
}),
|
|
);
|
|
|
|
expect(container.querySelectorAll('.ant-table-tbody tr.ant-table-row')).toHaveLength(
|
|
data.length,
|
|
);
|
|
|
|
fireEvent.click(container.querySelector('.ant-pagination .ant-pagination-item-2'));
|
|
expect(onChange.mock.calls[0][0].current).toBe(2);
|
|
expect(onChange).toHaveBeenCalledWith(
|
|
{ current: 2, pageSize: 10, total: 200 },
|
|
{},
|
|
{},
|
|
{
|
|
currentDataSource: [
|
|
{ key: 0, name: 'Jack' },
|
|
{ key: 1, name: 'Lucy' },
|
|
{ key: 2, name: 'Tom' },
|
|
{ key: 3, name: 'Jerry' },
|
|
],
|
|
action: 'paginate',
|
|
},
|
|
);
|
|
expect(onPaginationChange).toHaveBeenCalledWith(2, 10);
|
|
|
|
expect(container.querySelectorAll('.ant-table-tbody tr.ant-table-row')).toHaveLength(
|
|
data.length,
|
|
);
|
|
});
|
|
|
|
it('onShowSizeChange should trigger once', () => {
|
|
jest.useFakeTimers();
|
|
const onShowSizeChange = jest.fn();
|
|
const onChange = jest.fn();
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: {
|
|
total: 200,
|
|
showSizeChanger: true,
|
|
onShowSizeChange,
|
|
},
|
|
onChange,
|
|
}),
|
|
);
|
|
|
|
fireEvent.mouseDown(container.querySelector('.ant-select-selector'));
|
|
// resolve Warning: An update to Align ran an effect, but was not wrapped in act(...)
|
|
act(() => {
|
|
jest.runAllTimers();
|
|
});
|
|
expect(container.querySelectorAll('.ant-select-item-option').length).toBe(4);
|
|
fireEvent.click(container.querySelectorAll('.ant-select-item-option')[3]);
|
|
expect(onShowSizeChange).toHaveBeenCalledTimes(1);
|
|
expect(onShowSizeChange).toHaveBeenLastCalledWith(1, 100);
|
|
expect(onChange).toHaveBeenCalled();
|
|
jest.useRealTimers();
|
|
});
|
|
|
|
it('should support current in pagination', () => {
|
|
const { container } = render(createTable({ pagination: { current: 2, pageSize: 1 } }));
|
|
expect(container.querySelector('.ant-pagination-item-active').textContent).toBe('2');
|
|
});
|
|
|
|
it('should support defaultCurrent in pagination', () => {
|
|
const { container } = render(createTable({ pagination: { defaultCurrent: 2, pageSize: 1 } }));
|
|
expect(container.querySelector('.ant-pagination-item-active').textContent).toBe('2');
|
|
});
|
|
|
|
it('should support defaultPageSize in pagination', () => {
|
|
const { container } = render(createTable({ pagination: { defaultPageSize: 1 } }));
|
|
expect(container.querySelectorAll('.ant-pagination-item')).toHaveLength(4);
|
|
});
|
|
|
|
// https://github.com/ant-design/ant-design/issues/19957
|
|
it('ajax should work with pagination', () => {
|
|
const { container, rerender } = render(createTable({ pagination: { total: 100 } }));
|
|
|
|
fireEvent.click(container.querySelector('.ant-pagination-item-2'));
|
|
rerender(createTable({ pagination: { current: 2, total: 100 } }));
|
|
|
|
expect(
|
|
container
|
|
.querySelector('.ant-pagination-item-2')
|
|
.className.includes('ant-pagination-item-active'),
|
|
).toBeTruthy();
|
|
});
|
|
|
|
it('pagination should ignore invalidate total', () => {
|
|
const { container } = render(createTable({ pagination: { total: null } }));
|
|
expect(container.querySelectorAll('.ant-pagination-item-1').length).toBeTruthy();
|
|
});
|
|
|
|
it('renders pagination topLeft and bottomRight', () => {
|
|
const { asFragment } = render(createTable({ pagination: ['topLeft', 'bottomRight'] }));
|
|
expect(asFragment().firstChild).toMatchSnapshot();
|
|
});
|
|
|
|
it('should call onChange when change pagination size', () => {
|
|
const onChange = jest.fn();
|
|
const { container } = render(
|
|
createTable({
|
|
pagination: {
|
|
total: 200,
|
|
showSizeChanger: true,
|
|
},
|
|
onChange,
|
|
}),
|
|
);
|
|
fireEvent.mouseDown(container.querySelector('.ant-select-selector'));
|
|
fireEvent.click(container.querySelectorAll('.ant-select-item-option')[2]);
|
|
expect(onChange).toBeCalledTimes(1);
|
|
});
|
|
|
|
it('dynamic warning', () => {
|
|
resetWarned();
|
|
const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
|
|
|
|
const dynamicData = [];
|
|
for (let i = 0; i < 15; i += 1) {
|
|
dynamicData.push({
|
|
key: i,
|
|
name: i,
|
|
});
|
|
}
|
|
|
|
const { container } = render(
|
|
createTable({
|
|
dataSource: dynamicData,
|
|
pagination: { total: 100, pageSize: 10, current: 2 },
|
|
}),
|
|
);
|
|
|
|
expect(container.querySelectorAll('tbody tr')).toHaveLength(5);
|
|
|
|
expect(errorSpy).toHaveBeenCalledWith(
|
|
'Warning: [antd: Table] `dataSource` length is less than `pagination.total` but large than `pagination.pageSize`. Please make sure your config correct data with async mode.',
|
|
);
|
|
});
|
|
|
|
it('should render pagination after last item on last page being removed', () => {
|
|
const total = data.length;
|
|
const paginationProp = {
|
|
pageSize: 1,
|
|
total,
|
|
current: total,
|
|
position: ['topLeft', 'bottomLeft'],
|
|
};
|
|
const { container, rerender } = render(
|
|
createTable({
|
|
pagination: paginationProp,
|
|
}),
|
|
);
|
|
rerender(
|
|
createTable({
|
|
dataSource: data.slice(total - 1),
|
|
pagination: { ...paginationProp, total: total - 1 },
|
|
}),
|
|
);
|
|
|
|
expect(container.querySelectorAll('.ant-pagination')).toHaveLength(2);
|
|
});
|
|
|
|
it('showTotal should hide when removed', () => {
|
|
const Demo = () => {
|
|
const [p, setP] = React.useState({
|
|
showTotal: t => `>${t}<`,
|
|
total: 200,
|
|
current: 1,
|
|
pageSize: 10,
|
|
});
|
|
|
|
return (
|
|
<Table
|
|
data={[]}
|
|
columns={[]}
|
|
pagination={p}
|
|
onChange={pg => {
|
|
setP({
|
|
...pg,
|
|
total: 23,
|
|
});
|
|
}}
|
|
/>
|
|
);
|
|
};
|
|
|
|
const { container } = render(<Demo />);
|
|
expect(container.querySelector('.ant-pagination-total-text').textContent).toEqual('>200<');
|
|
|
|
// Should hide
|
|
fireEvent.click(container.querySelector('.ant-pagination-item-2'));
|
|
expect(container.querySelectorAll('.ant-pagination-total-text')).toHaveLength(0);
|
|
});
|
|
|
|
it('should preserve table pagination className', () => {
|
|
const { container } = render(
|
|
<Table
|
|
data={[]}
|
|
columns={[]}
|
|
pagination={{
|
|
className: 'pagination',
|
|
total: 200,
|
|
current: 1,
|
|
pageSize: 10,
|
|
}}
|
|
/>,
|
|
);
|
|
expect(container.querySelector('.ant-pagination').className).toEqual(
|
|
'ant-pagination ant-table-pagination ant-table-pagination-right pagination',
|
|
);
|
|
});
|
|
});
|