(instance = i)} />;
}
test('renders only the child element', () => {
const stringContent = render(
,
);
expect(stringContent.container.innerHTML).toBe('');
const reactElementContent = render(
tooltip}>
,
);
expect(reactElementContent.container.innerHTML).toBe('');
});
test('adds a tippy instance to the child node', () => {
render(
,
);
expect(instance).not.toBeNull();
});
test('renders react element content inside the content prop', () => {
render(
tooltip}>
,
);
expect(instance.popper.querySelector('strong')).not.toBeNull();
});
test('cleans up after unmounting in tests', async () => {
render(
,
);
// open up the tooltip
screen.getByRole('button').click();
expect(screen.getByText('tooltip')).toBeInTheDocument();
// close the tooltip
screen.getByRole('button').click();
await waitForElementToBeRemoved(() => screen.queryByText('tooltip'));
});
test('props.className: single name is added to tooltip', () => {
const className = 'hello';
render(
,
);
expect(instance.popper.querySelector(`.${className}`)).not.toBeNull();
});
test('props.className: multiple names are added to tooltip', () => {
const classNames = 'hello world';
render(
,
);
expect(instance.popper.querySelector('.hello')).not.toBeNull();
expect(instance.popper.querySelector('.world')).not.toBeNull();
});
test('props.className: extra whitespace is ignored', () => {
const className = ' hello world ';
render(
,
);
const box = instance.popper.firstElementChild;
expect(box.className).toBe('tippy-box hello world');
});
test('props.className: updating does not leave stale className behind', () => {
const {rerender} = render(
,
);
const box = instance.popper.firstElementChild;
expect(box.classList.contains('one')).toBe(true);
rerender(
,
);
expect(box.classList.contains('one')).toBe(false);
expect(box.classList.contains('two')).toBe(true);
});
test('props.className: syncs with children.type', () => {
const {rerender} = render(
,
);
rerender(
,
);
const box = instance.popper.firstElementChild;
expect(box.classList.contains('one')).toBe(true);
});
test('unmount destroys the tippy instance and allows garbage collection', () => {
const {container, unmount} = render(
,
);
const button = container.querySelector('button');
unmount();
expect(button._tippy).toBeUndefined();
expect(instance.state.isDestroyed).toBe(true);
});
test('updating children destroys old instance and creates new one', () => {
const Button = (_, ref) => ;
const Main = (_, ref) => ;
const Component1 = React.forwardRef(Button);
const Component2 = React.forwardRef(Main);
const {container, rerender} = render(
,
);
const div = container.querySelector('div');
rerender(
,
);
const span = container.querySelector('span');
expect(div._tippy).toBeUndefined();
expect(span._tippy).toBeDefined();
rerender(
,
);
const button = container.querySelector('button');
expect(span._tippy).toBeUndefined();
expect(button._tippy).toBeDefined();
rerender(
,
);
expect(button._tippy).toBeUndefined();
expect(container.querySelector('main')._tippy).toBeDefined();
});
test('updating props updates the tippy instance', () => {
const {rerender} = render(
,
);
expect(instance.props.arrow).toBe(false);
rerender(
,
);
expect(instance.props.arrow).toBe(true);
});
test('props containing refs updates the tippy instance on mount', () => {
const App = () => {
const [triggerTarget, setTriggerTarget] = React.useState(null);
return (
setTriggerTarget(el)}>
Trigger Target
);
};
const {container} = render();
const instanceNode = container.querySelector('button');
const instance = instanceNode._tippy;
expect(instance.props.triggerTarget).toBe(instanceNode.parentNode);
});
test('component as a child', () => {
const Child = React.forwardRef(function Comp(_, ref) {
return ;
});
render(
,
);
expect(instance).not.toBeNull();
});
test('refs are preserved on the child', done => {
class App extends React.Component {
constructor(props) {
super(props);
this.refObject = React.createRef();
}
componentDidMount() {
expect(this.callbackRef instanceof Element).toBe(true);
expect(this.refObject.current instanceof Element).toBe(true);
done();
}
render() {
return (
<>
>
);
}
}
render();
});
test('nesting', () => {
render(
,
);
expect(document.querySelectorAll('.tippy-box').length).toBe(3);
});
test('props.disabled initially `false`', () => {
const {rerender} = render(
,
);
expect(instance.state.isEnabled).toBe(true);
rerender(
,
);
expect(instance.state.isEnabled).toBe(false);
});
test('props.disabled initially `true`', () => {
const {rerender} = render(
,
);
expect(instance.state.isEnabled).toBe(false);
rerender(
,
);
expect(instance.state.isEnabled).toBe(true);
});
test('props.visible initially `true`', () => {
const {rerender} = render(
,
);
expect(instance.state.isVisible).toBe(true);
rerender(
,
);
expect(instance.state.isVisible).toBe(false);
});
test('props.visible initially `false`', () => {
const {rerender} = render(
,
);
expect(instance.state.isVisible).toBe(false);
rerender(
,
);
expect(instance.state.isVisible).toBe(true);
});
test('props.visible uses hideOnClick: false by default', () => {
const {rerender} = render(
,
);
jest.runAllTimers();
expect(instance.props.hideOnClick).toBe(false);
rerender(
,
);
expect(instance.props.hideOnClick).toBe(false);
rerender(
,
);
expect(instance.props.hideOnClick).toBe(false);
rerender(
,
);
expect(instance.props.hideOnClick).toBe('toggle');
});
test('controlled mode warnings', () => {
const spy = jest.spyOn(console, 'warn');
const {rerender} = render(
,
);
expect(spy).not.toHaveBeenCalled();
rerender(
,
);
expect(spy).toHaveBeenCalledWith(
[
'@tippyjs/react: Cannot specify `hideOnClick` prop in controlled',
'mode (`visible` prop)',
].join(' '),
);
rerender(
,
);
expect(spy).toHaveBeenCalledWith(
[
'@tippyjs/react: Cannot specify `trigger` prop in controlled',
'mode (`visible` prop)',
].join(' '),
);
});
test('props.plugins', () => {
const plugins = [{fn: () => ({})}];
render(
,
);
expect(instance.plugins).toMatchSnapshot();
});
test('render prop', () => {
render(
Hello
} showOnCreate={true}>
,
);
jest.runAllTimers();
expect(instance.popper.firstElementChild).toMatchSnapshot();
});
test('render prop instance', () => {
let _instance;
render(
{
_instance = instance;
return Hello
;
}}
showOnCreate={true}
>
,
);
jest.runAllTimers();
expect(_instance).toBe(instance);
});
test('render prop preserve popperOptions', () => {
const element = (
Hello
}
popperOptions={{
strategy: 'fixed',
modifiers: [{name: 'x', enabled: true, phase: 'main', fn: () => {}}],
}}
>
);
const {rerender} = render(element);
rerender(element);
expect(instance.props.popperOptions).toMatchSnapshot();
});
test('render + className prop warning', () => {
const spy = jest.spyOn(console, 'warn');
render( } className="x" />);
expect(spy).toHaveBeenCalledWith(
[
'@tippyjs/react: Cannot use `className` prop in conjunction with',
'`render` prop. Place the className on the element you are',
'rendering.',
].join(' '),
);
spy.mockReset();
render( } />);
render();
expect(spy).not.toHaveBeenCalled();
});
test('`reference` prop as RefObject', () => {
function App() {
const ref = useRef();
return (
<>
>
);
}
render();
expect(instance.reference.getAttribute('data-testid')).toBe(
'reference-prop',
);
});
test('`reference` prop as Element', () => {
function App() {
const [element, setElement] = useState(null);
return (
<>
>
);
}
render();
expect(instance.reference.getAttribute('data-testid')).toBe(
'reference-prop',
);
});
});
describe('Tippy.propTypes', () => {
const originalEnv = process.env.NODE_ENV;
beforeEach(() => {
jest.resetModules();
});
afterEach(() => {
process.env.NODE_ENV = originalEnv;
});
test('is undefined if NODE_ENV=production', () => {
process.env.NODE_ENV = 'production';
const TippyGenerator = require('../src/Tippy').default;
expect(TippyGenerator().propTypes).toBeUndefined();
});
});