maxjhandsome
/
react
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Upgrade to Jest 23 (#12894) 

* Upgrade to Jest 23 beta

* prefer `.toHaveBeenCalledTimes`

* 23 stable
This commit is contained in:
Simen Bekkhus 2018-05-29 00:03:15 +02:00 committed by Dan Abramov
parent a32f857ac7
commit aa85b0fd5f
28 changed files with 602 additions and 1004 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
package.json
View File

@ -11,7 +11,7 @@
"babel-code-frame": "^6.26.0",
"babel-core": "^6.0.0",
"babel-eslint": "^8.0.0",
"babel-jest": "^22.4.4",
"babel-jest": "^23.0.1",
"babel-plugin-check-es2015-constants": "^6.5.0",
"babel-plugin-external-helpers": "^6.22.0",
"babel-plugin-syntax-trailing-function-commas": "^6.5.0",
@ -69,8 +69,8 @@
"gzip-js": "~0.3.2",
"gzip-size": "^3.0.0",
"jasmine-check": "^1.0.0-rc.0",
"jest": "^22.4.4",
"jest-diff": "^22.4.3",
"jest": "^23.0.1",
"jest-diff": "^23.0.1",
"merge-stream": "^1.0.0",
"minimatch": "^3.0.4",
"minimist": "^1.2.0",

2
packages/react-dom/src/__tests__/DOMPropertyOperations-test.js vendored
View File

@ -123,7 +123,7 @@ describe('DOMPropertyOperations', () => {
spyOnDevAndProd(container.firstChild, 'setAttribute');
ReactDOM.render(<progress value={30} />, container);
ReactDOM.render(<progress value="30" />, container);
expect(container.firstChild.setAttribute.calls.count()).toBe(2);
expect(container.firstChild.setAttribute).toHaveBeenCalledTimes(2);
});
});

12
packages/react-dom/src/__tests__/ReactBrowserEventEmitter-test.internal.js
View File

@ -151,17 +151,17 @@ describe('ReactBrowserEventEmitter', () => {
it('should invoke a simple handler registered on a node', () => {
registerSimpleTestHandler();
ReactTestUtils.Simulate.click(CHILD);
expect(LISTENER.mock.calls.length).toBe(1);
expect(LISTENER).toHaveBeenCalledTimes(1);
});
it('should not invoke handlers if ReactBrowserEventEmitter is disabled', () => {
registerSimpleTestHandler();
ReactBrowserEventEmitter.setEnabled(false);
ReactTestUtils.SimulateNative.click(CHILD);
expect(LISTENER.mock.calls.length).toBe(0);
expect(LISTENER).toHaveBeenCalledTimes(0);
ReactBrowserEventEmitter.setEnabled(true);
ReactTestUtils.SimulateNative.click(CHILD);
expect(LISTENER.mock.calls.length).toBe(1);
expect(LISTENER).toHaveBeenCalledTimes(1);
});
it('should bubble simply', () => {
@ -301,7 +301,7 @@ describe('ReactBrowserEventEmitter', () => {
putListener(CHILD, ON_CLICK_KEY, handleChildClick);
putListener(PARENT, ON_CLICK_KEY, handleParentClick);
ReactTestUtils.Simulate.click(CHILD);
expect(handleParentClick.mock.calls.length).toBe(1);
expect(handleParentClick).toHaveBeenCalledTimes(1);
});
it('should not invoke newly inserted handlers while bubbling', () => {
@ -311,7 +311,7 @@ describe('ReactBrowserEventEmitter', () => {
};
putListener(CHILD, ON_CLICK_KEY, handleChildClick);
ReactTestUtils.Simulate.click(CHILD);
expect(handleParentClick.mock.calls.length).toBe(0);
expect(handleParentClick).toHaveBeenCalledTimes(0);
});
it('should have mouse enter simulated by test utils', () => {
@ -325,7 +325,7 @@ describe('ReactBrowserEventEmitter', () => {
spyOnDevAndProd(EventTarget.prototype, 'addEventListener');
ReactBrowserEventEmitter.listenTo(ON_CLICK_KEY, document);
ReactBrowserEventEmitter.listenTo(ON_CLICK_KEY, document);
expect(EventTarget.prototype.addEventListener.calls.count()).toBe(1);
expect(EventTarget.prototype.addEventListener).toHaveBeenCalledTimes(1);
});
it('should work with event plugins without dependencies', () => {

6
packages/react-dom/src/__tests__/ReactComponent-test.js vendored
View File

@ -387,11 +387,11 @@ describe('ReactComponent', () => {
const callback = jest.fn();
const container = document.createElement('div');
ReactDOM.render(<div />, container, callback);
expect(callback.mock.calls.length).toBe(1);
expect(callback).toHaveBeenCalledTimes(1);
ReactDOM.render(<div className="foo" />, container, callback);
expect(callback.mock.calls.length).toBe(2);
expect(callback).toHaveBeenCalledTimes(2);
ReactDOM.render(<span />, container, callback);
expect(callback.mock.calls.length).toBe(3);
expect(callback).toHaveBeenCalledTimes(3);
});
it('throws usefully when rendering badly-typed elements', () => {

54
packages/react-dom/src/__tests__/ReactDOMComponent-test.js vendored
View File

@ -738,28 +738,28 @@ describe('ReactDOMComponent', () => {
node.removeAttribute.mockImplementation(nodeRemoveAttribute);
ReactDOM.render(<div id="" />, container);
expect(node.setAttribute.mock.calls.length).toBe(0);
expect(node.removeAttribute.mock.calls.length).toBe(0);
expect(node.setAttribute).toHaveBeenCalledTimes(0);
expect(node.removeAttribute).toHaveBeenCalledTimes(0);
ReactDOM.render(<div id="foo" />, container);
expect(node.setAttribute.mock.calls.length).toBe(1);
expect(node.removeAttribute.mock.calls.length).toBe(0);
expect(node.setAttribute).toHaveBeenCalledTimes(1);
expect(node.removeAttribute).toHaveBeenCalledTimes(0);
ReactDOM.render(<div id="foo" />, container);
expect(node.setAttribute.mock.calls.length).toBe(1);
expect(node.removeAttribute.mock.calls.length).toBe(0);
expect(node.setAttribute).toHaveBeenCalledTimes(1);
expect(node.removeAttribute).toHaveBeenCalledTimes(0);
ReactDOM.render(<div />, container);
expect(node.setAttribute.mock.calls.length).toBe(1);
expect(node.removeAttribute.mock.calls.length).toBe(1);
expect(node.setAttribute).toHaveBeenCalledTimes(1);
expect(node.removeAttribute).toHaveBeenCalledTimes(1);
ReactDOM.render(<div id="" />, container);
expect(node.setAttribute.mock.calls.length).toBe(2);
expect(node.removeAttribute.mock.calls.length).toBe(1);
expect(node.setAttribute).toHaveBeenCalledTimes(2);
expect(node.removeAttribute).toHaveBeenCalledTimes(1);
ReactDOM.render(<div />, container);
expect(node.setAttribute.mock.calls.length).toBe(2);
expect(node.removeAttribute.mock.calls.length).toBe(2);
expect(node.setAttribute).toHaveBeenCalledTimes(2);
expect(node.removeAttribute).toHaveBeenCalledTimes(2);
});
it('should not incur unnecessary DOM mutations for string properties', () => {
@ -768,7 +768,7 @@ describe('ReactDOMComponent', () => {
const node = container.firstChild;
const nodeValueSetter = jest.genMockFn();
const nodeValueSetter = jest.fn();
const oldSetAttribute = node.setAttribute.bind(node);
node.setAttribute = function(key, value) {
@ -777,22 +777,22 @@ describe('ReactDOMComponent', () => {
};
ReactDOM.render(<div value="foo" />, container);
expect(nodeValueSetter.mock.calls.length).toBe(1);
expect(nodeValueSetter).toHaveBeenCalledTimes(1);
ReactDOM.render(<div value="foo" />, container);
expect(nodeValueSetter.mock.calls.length).toBe(1);
expect(nodeValueSetter).toHaveBeenCalledTimes(1);
ReactDOM.render(<div />, container);
expect(nodeValueSetter.mock.calls.length).toBe(1);
expect(nodeValueSetter).toHaveBeenCalledTimes(1);
ReactDOM.render(<div value={null} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(1);
expect(nodeValueSetter).toHaveBeenCalledTimes(1);
ReactDOM.render(<div value="" />, container);
expect(nodeValueSetter.mock.calls.length).toBe(2);
expect(nodeValueSetter).toHaveBeenCalledTimes(2);
ReactDOM.render(<div />, container);
expect(nodeValueSetter.mock.calls.length).toBe(2);
expect(nodeValueSetter).toHaveBeenCalledTimes(2);
});
it('should not incur unnecessary DOM mutations for boolean properties', () => {
@ -812,16 +812,16 @@ describe('ReactDOMComponent', () => {
});
ReactDOM.render(<div checked={true} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(0);
expect(nodeValueSetter).toHaveBeenCalledTimes(0);
ReactDOM.render(<div />, container);
expect(nodeValueSetter.mock.calls.length).toBe(1);
expect(nodeValueSetter).toHaveBeenCalledTimes(1);
ReactDOM.render(<div checked={false} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(2);
expect(nodeValueSetter).toHaveBeenCalledTimes(2);
ReactDOM.render(<div checked={true} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(3);
expect(nodeValueSetter).toHaveBeenCalledTimes(3);
});
it('should ignore attribute whitelist for elements with the "is" attribute', () => {
@ -850,9 +850,9 @@ describe('ReactDOMComponent', () => {
ReactDOM.render(<div dir={null} />, container);
ReactDOM.render(<div dir={undefined} />, container);
ReactDOM.render(<div />, container);
expect(setter.mock.calls.length).toBe(0);
expect(setter).toHaveBeenCalledTimes(0);
ReactDOM.render(<div dir="ltr" />, container);
expect(setter.mock.calls.length).toBe(1);
expect(setter).toHaveBeenCalledTimes(1);
});
it('handles multiple child updates without interference', () => {
@ -984,7 +984,7 @@ describe('ReactDOMComponent', () => {
container.getElementsByTagName('source')[0].dispatchEvent(errorEvent);
if (__DEV__) {
expect(console.log.calls.count()).toBe(1);
expect(console.log).toHaveBeenCalledTimes(1);
expect(console.log.calls.argsFor(0)[0]).toContain('onError called');
}
});
@ -1315,7 +1315,7 @@ describe('ReactDOMComponent', () => {
container.getElementsByTagName('image')[0].dispatchEvent(loadEvent);
if (__DEV__) {
expect(console.log.calls.count()).toBe(2);
expect(console.log).toHaveBeenCalledTimes(2);
expect(console.log.calls.argsFor(0)[0]).toContain('onError called');
expect(console.log.calls.argsFor(1)[0]).toContain('onLoad called');
}

8
packages/react-dom/src/__tests__/ReactDOMEventListener-test.js vendored
View File

@ -61,7 +61,7 @@ describe('ReactDOMEventListener', () => {
childNode.dispatchEvent(nativeEvent);
expect(mouseOut).toBeCalled();
expect(mouseOut.mock.calls.length).toBe(2);
expect(mouseOut).toHaveBeenCalledTimes(2);
expect(mouseOut.mock.calls[0][0]).toEqual(childNode);
expect(mouseOut.mock.calls[1][0]).toEqual(parentNode);
@ -97,7 +97,7 @@ describe('ReactDOMEventListener', () => {
childNode.dispatchEvent(nativeEvent);
expect(mouseOut).toBeCalled();
expect(mouseOut.mock.calls.length).toBe(3);
expect(mouseOut).toHaveBeenCalledTimes(3);
expect(mouseOut.mock.calls[0][0]).toEqual(childNode);
expect(mouseOut.mock.calls[1][0]).toEqual(parentNode);
expect(mouseOut.mock.calls[2][0]).toEqual(grandParentNode);
@ -169,7 +169,7 @@ describe('ReactDOMEventListener', () => {
childNode.dispatchEvent(nativeEvent);
// Child and parent should both call from event handlers.
expect(mock.mock.calls.length).toBe(2);
expect(mock).toHaveBeenCalledTimes(2);
// The first call schedules a render of '1' into the 'Child'.
// However, we're batching so it isn't flushed yet.
expect(mock.mock.calls[0][0]).toBe('Child');
@ -213,7 +213,7 @@ describe('ReactDOMEventListener', () => {
instance.getInner().dispatchEvent(nativeEvent);
expect(mouseOut).toBeCalled();
expect(mouseOut.mock.calls.length).toBe(1);
expect(mouseOut).toHaveBeenCalledTimes(1);
expect(mouseOut.mock.calls[0][0]).toEqual(instance.getInner());
document.body.removeChild(container);
});

2
packages/react-dom/src/__tests__/ReactDOMIframe-test.js vendored
View File

@ -21,7 +21,7 @@ describe('ReactDOMIframe', () => {
});
it('should trigger load events', () => {
const onLoadSpy = jasmine.createSpy();
const onLoadSpy = jest.fn();
let iframe = React.createElement('iframe', {onLoad: onLoadSpy});
iframe = ReactTestUtils.renderIntoDocument(iframe);

14
packages/react-dom/src/__tests__/ReactDOMInput-test.js vendored
View File

@ -535,7 +535,7 @@ describe('ReactDOMInput', () => {
const node = container.firstChild;
let nodeValue = 'a';
const nodeValueSetter = jest.genMockFn();
const nodeValueSetter = jest.fn();
Object.defineProperty(node, 'value', {
get: function() {
return nodeValue;
@ -546,10 +546,10 @@ describe('ReactDOMInput', () => {
});
ReactDOM.render(<input value="a" onChange={() => {}} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(0);
expect(nodeValueSetter).toHaveBeenCalledTimes(0);
ReactDOM.render(<input value="b" onChange={() => {}} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(1);
expect(nodeValueSetter).toHaveBeenCalledTimes(1);
});
it('should not incur unnecessary DOM mutations for numeric type conversion', () => {
@ -558,7 +558,7 @@ describe('ReactDOMInput', () => {
const node = container.firstChild;
let nodeValue = '0';
const nodeValueSetter = jest.genMockFn();
const nodeValueSetter = jest.fn();
Object.defineProperty(node, 'value', {
get: function() {
return nodeValue;
@ -569,7 +569,7 @@ describe('ReactDOMInput', () => {
});
ReactDOM.render(<input value={0} onChange={() => {}} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(0);
expect(nodeValueSetter).toHaveBeenCalledTimes(0);
});
it('should not incur unnecessary DOM mutations for the boolean type conversion', () => {
@ -578,7 +578,7 @@ describe('ReactDOMInput', () => {
const node = container.firstChild;
let nodeValue = 'true';
const nodeValueSetter = jest.genMockFn();
const nodeValueSetter = jest.fn();
Object.defineProperty(node, 'value', {
get: function() {
return nodeValue;
@ -589,7 +589,7 @@ describe('ReactDOMInput', () => {
});
ReactDOM.render(<input value={true} onChange={() => {}} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(0);
expect(nodeValueSetter).toHaveBeenCalledTimes(0);
});
it('should properly control a value of number `0`', () => {

6
packages/react-dom/src/__tests__/ReactDOMTextarea-test.js vendored
View File

@ -218,7 +218,7 @@ describe('ReactDOMTextarea', () => {
const node = container.firstChild;
let nodeValue = 'a';
const nodeValueSetter = jest.genMockFn();
const nodeValueSetter = jest.fn();
Object.defineProperty(node, 'value', {
get: function() {
return nodeValue;
@ -229,10 +229,10 @@ describe('ReactDOMTextarea', () => {
});
ReactDOM.render(<textarea value="a" onChange={emptyFunction} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(0);
expect(nodeValueSetter).toHaveBeenCalledTimes(0);
ReactDOM.render(<textarea value="b" onChange={emptyFunction} />, container);
expect(nodeValueSetter.mock.calls.length).toBe(1);
expect(nodeValueSetter).toHaveBeenCalledTimes(1);
});
it('should properly control a value of number `0`', () => {

73
packages/react-dom/src/__tests__/ReactEmptyComponent-test.js vendored
View File

@ -24,7 +24,7 @@ describe('ReactEmptyComponent', () => {
ReactDOM = require('react-dom');
ReactTestUtils = require('react-dom/test-utils');
log = jasmine.createSpy();
log = jest.fn();
TogglingComponent = class extends React.Component {
state = {component: this.props.firstComponent};
@ -91,11 +91,17 @@ describe('ReactEmptyComponent', () => {
ReactTestUtils.renderIntoDocument(instance1);
ReactTestUtils.renderIntoDocument(instance2);
expect(log.calls.count()).toBe(4);
expect(log.calls.argsFor(0)[0]).toBe(null);
expect(log.calls.argsFor(1)[0].tagName).toBe('DIV');
expect(log.calls.argsFor(2)[0].tagName).toBe('DIV');
expect(log.calls.argsFor(3)[0]).toBe(null);
expect(log).toHaveBeenCalledTimes(4);
expect(log).toHaveBeenNthCalledWith(1, null);
expect(log).toHaveBeenNthCalledWith(
2,
expect.objectContaining({tagName: 'DIV'}),
);
expect(log).toHaveBeenNthCalledWith(
3,
expect.objectContaining({tagName: 'DIV'}),
);
expect(log).toHaveBeenNthCalledWith(4, null);
});
it('should be able to switch in a list of children', () => {
@ -111,13 +117,22 @@ describe('ReactEmptyComponent', () => {
</div>,
);
expect(log.calls.count()).toBe(6);
expect(log.calls.argsFor(0)[0]).toBe(null);
expect(log.calls.argsFor(1)[0]).toBe(null);
expect(log.calls.argsFor(2)[0]).toBe(null);
expect(log.calls.argsFor(3)[0].tagName).toBe('DIV');
expect(log.calls.argsFor(4)[0].tagName).toBe('DIV');
expect(log.calls.argsFor(5)[0].tagName).toBe('DIV');
expect(log).toHaveBeenCalledTimes(6);
expect(log).toHaveBeenNthCalledWith(1, null);
expect(log).toHaveBeenNthCalledWith(2, null);
expect(log).toHaveBeenNthCalledWith(3, null);
expect(log).toHaveBeenNthCalledWith(
4,
expect.objectContaining({tagName: 'DIV'}),
);
expect(log).toHaveBeenNthCalledWith(
5,
expect.objectContaining({tagName: 'DIV'}),
);
expect(log).toHaveBeenNthCalledWith(
6,
expect.objectContaining({tagName: 'DIV'}),
);
});
it('should distinguish between a script placeholder and an actual script tag', () => {
@ -135,11 +150,17 @@ describe('ReactEmptyComponent', () => {
ReactTestUtils.renderIntoDocument(instance2);
}).not.toThrow();
expect(log.calls.count()).toBe(4);
expect(log.calls.argsFor(0)[0]).toBe(null);
expect(log.calls.argsFor(1)[0].tagName).toBe('SCRIPT');
expect(log.calls.argsFor(2)[0].tagName).toBe('SCRIPT');
expect(log.calls.argsFor(3)[0]).toBe(null);
expect(log).toHaveBeenCalledTimes(4);
expect(log).toHaveBeenNthCalledWith(1, null);
expect(log).toHaveBeenNthCalledWith(
2,
expect.objectContaining({tagName: 'SCRIPT'}),
);
expect(log).toHaveBeenNthCalledWith(
3,
expect.objectContaining({tagName: 'SCRIPT'}),
);
expect(log).toHaveBeenNthCalledWith(4, null);
});
it(
@ -172,11 +193,17 @@ describe('ReactEmptyComponent', () => {
ReactTestUtils.renderIntoDocument(instance2);
}).not.toThrow();
expect(log.calls.count()).toBe(4);
expect(log.calls.argsFor(0)[0].tagName).toBe('DIV');
expect(log.calls.argsFor(1)[0]).toBe(null);
expect(log.calls.argsFor(2)[0]).toBe(null);
expect(log.calls.argsFor(3)[0].tagName).toBe('DIV');
expect(log).toHaveBeenCalledTimes(4);
expect(log).toHaveBeenNthCalledWith(
1,
expect.objectContaining({tagName: 'DIV'}),
);
expect(log).toHaveBeenNthCalledWith(2, null);
expect(log).toHaveBeenNthCalledWith(3, null);
expect(log).toHaveBeenNthCalledWith(
4,
expect.objectContaining({tagName: 'DIV'}),
);
},
);

16
packages/react-dom/src/__tests__/ReactMount-test.js vendored
View File

@ -91,25 +91,25 @@ describe('ReactMount', () => {
}
}
expect(mockMount.mock.calls.length).toBe(0);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(0);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(<Component text="orange" key="A" />, container);
expect(container.firstChild.innerHTML).toBe('orange');
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUnmount).toHaveBeenCalledTimes(0);
// If we change the key, the component is unmounted and remounted
ReactDOM.render(<Component text="green" key="B" />, container);
expect(container.firstChild.innerHTML).toBe('green');
expect(mockMount.mock.calls.length).toBe(2);
expect(mockUnmount.mock.calls.length).toBe(1);
expect(mockMount).toHaveBeenCalledTimes(2);
expect(mockUnmount).toHaveBeenCalledTimes(1);
// But if we don't change the key, the component instance is reused
ReactDOM.render(<Component text="blue" key="B" />, container);
expect(container.firstChild.innerHTML).toBe('blue');
expect(mockMount.mock.calls.length).toBe(2);
expect(mockUnmount.mock.calls.length).toBe(1);
expect(mockMount).toHaveBeenCalledTimes(2);
expect(mockUnmount).toHaveBeenCalledTimes(1);
});
it('should reuse markup if rendering to the same target twice', () => {

54
packages/react-dom/src/__tests__/ReactMultiChild-test.js vendored
View File

@ -36,9 +36,9 @@ describe('ReactMultiChild', () => {
}
}
expect(mockMount.mock.calls.length).toBe(0);
expect(mockUpdate.mock.calls.length).toBe(0);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(0);
expect(mockUpdate).toHaveBeenCalledTimes(0);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(
<div>
@ -47,9 +47,9 @@ describe('ReactMultiChild', () => {
container,
);
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUpdate.mock.calls.length).toBe(0);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUpdate).toHaveBeenCalledTimes(0);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(
<div>
@ -58,9 +58,9 @@ describe('ReactMultiChild', () => {
container,
);
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUpdate.mock.calls.length).toBe(1);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUpdate).toHaveBeenCalledTimes(1);
expect(mockUnmount).toHaveBeenCalledTimes(0);
});
it('should replace children with different constructors', () => {
@ -77,8 +77,8 @@ describe('ReactMultiChild', () => {
}
}
expect(mockMount.mock.calls.length).toBe(0);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(0);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(
<div>
@ -87,8 +87,8 @@ describe('ReactMultiChild', () => {
container,
);
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(
<div>
@ -97,8 +97,8 @@ describe('ReactMultiChild', () => {
container,
);
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUnmount.mock.calls.length).toBe(1);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUnmount).toHaveBeenCalledTimes(1);
});
it('should NOT replace children with different owners', () => {
@ -121,13 +121,13 @@ describe('ReactMultiChild', () => {
}
}
expect(mockMount.mock.calls.length).toBe(0);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(0);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(<WrapperComponent />, container);
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(
<WrapperComponent>
@ -136,8 +136,8 @@ describe('ReactMultiChild', () => {
container,
);
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUnmount).toHaveBeenCalledTimes(0);
});
it('should replace children with different keys', () => {
@ -154,8 +154,8 @@ describe('ReactMultiChild', () => {
}
}
expect(mockMount.mock.calls.length).toBe(0);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(0);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(
<div>
@ -164,8 +164,8 @@ describe('ReactMultiChild', () => {
container,
);
expect(mockMount.mock.calls.length).toBe(1);
expect(mockUnmount.mock.calls.length).toBe(0);
expect(mockMount).toHaveBeenCalledTimes(1);
expect(mockUnmount).toHaveBeenCalledTimes(0);
ReactDOM.render(
<div>
@ -174,8 +174,8 @@ describe('ReactMultiChild', () => {
container,
);
expect(mockMount.mock.calls.length).toBe(2);
expect(mockUnmount.mock.calls.length).toBe(1);
expect(mockMount).toHaveBeenCalledTimes(2);
expect(mockUnmount).toHaveBeenCalledTimes(1);
});
it('should warn for duplicated array keys with component stack info', () => {

12
packages/react-dom/src/__tests__/ReactTestUtils-test.js vendored
View File

@ -290,7 +290,7 @@ describe('ReactTestUtils', () => {
ReactTestUtils.Simulate.change(node);
expect(obj.handler).toHaveBeenCalledWith(
jasmine.objectContaining({target: node}),
expect.objectContaining({target: node}),
);
});
@ -326,7 +326,7 @@ describe('ReactTestUtils', () => {
ReactTestUtils.Simulate.change(node);
expect(obj.handler).toHaveBeenCalledWith(
jasmine.objectContaining({target: node}),
expect.objectContaining({target: node}),
);
});
@ -337,7 +337,7 @@ describe('ReactTestUtils', () => {
}
}
const handler = jasmine.createSpy('spy');
const handler = jest.fn().mockName('spy');
const shallowRenderer = createRenderer();
const result = shallowRenderer.render(
<SomeComponent handleClick={handler} />,
@ -358,7 +358,7 @@ describe('ReactTestUtils', () => {
}
}
const handler = jasmine.createSpy('spy');
const handler = jest.fn().mockName('spy');
const container = document.createElement('div');
const instance = ReactDOM.render(
<SomeComponent handleClick={handler} />,
@ -394,7 +394,7 @@ describe('ReactTestUtils', () => {
it('should set the type of the event', () => {
let event;
const stub = jest.genMockFn().mockImplementation(e => {
const stub = jest.fn().mockImplementation(e => {
e.persist();
event = e;
});
@ -431,7 +431,7 @@ describe('ReactTestUtils', () => {
ReactTestUtils.Simulate.change(input);
expect(onChange).toHaveBeenCalledWith(
jasmine.objectContaining({target: input}),
expect.objectContaining({target: input}),
);
});
});

2
packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js vendored
View File

@ -63,7 +63,7 @@ module.exports = function(initModules) {
}
}
if (__DEV__) {
expect(console.error.calls.count()).toBe(count);
expect(console.error).toHaveBeenCalledTimes(count);
}
return result;
}

156
packages/react-dom/src/events/__tests__/BeforeInputEventPlugin-test.js vendored
View File

@ -200,9 +200,9 @@ describe('BeforeInputEventPlugin', () => {
spyOnBeforeInput,
spyOnCompositionStart,
}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
expect(spyOnCompositionStart.mock.calls.length).toBe(1);
expect(spyOnCompositionStart).toHaveBeenCalledTimes(1);
expect(compositionStartEvent.type).toBe('compositionstart');
expect(compositionStartEvent.data).toBe('test');
},
@ -214,116 +214,116 @@ describe('BeforeInputEventPlugin', () => {
spyOnBeforeInput,
spyOnCompositionUpdate,
}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
expect(spyOnCompositionUpdate.mock.calls.length).toBe(1);
expect(spyOnCompositionUpdate).toHaveBeenCalledTimes(1);
expect(compositionUpdateEvent.type).toBe('compositionupdate');
expect(compositionUpdateEvent.data).toBe('test string');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('compositionend');
expect(beforeInputEvent.data).toBe('test string 3');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('textInput');
expect(beforeInputEvent.data).toBe('abcß');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe(' ');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('textInput');
expect(beforeInputEvent.data).toBe('\uD83D\uDE0A');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
@ -334,119 +334,119 @@ describe('BeforeInputEventPlugin', () => {
assertions: [
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('a');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe(' ');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('c');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('\uD83D\uDE0A');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
@ -457,122 +457,122 @@ describe('BeforeInputEventPlugin', () => {
assertions: [
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('a');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe(' ');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('c');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('\uD83D\uDE0A');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keydown');
expect(beforeInputEvent.data).toBe('bar');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keyup');
expect(beforeInputEvent.data).toBe('BAR');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('Bar');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
@ -583,120 +583,120 @@ describe('BeforeInputEventPlugin', () => {
assertions: [
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('compositionend');
expect(beforeInputEvent.data).toBe('test string 3');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('a');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe(' ');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('c');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(1);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(1);
expect(beforeInputEvent.type).toBe('keypress');
expect(beforeInputEvent.data).toBe('\uD83D\uDE0A');
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},
{
run: ({beforeInputEvent, spyOnBeforeInput}) => {
expect(spyOnBeforeInput.mock.calls.length).toBe(0);
expect(spyOnBeforeInput).toHaveBeenCalledTimes(0);
expect(beforeInputEvent).toBeNull();
},
},

8
packages/react-dom/src/events/__tests__/SelectEventPlugin-test.js vendored
View File

@ -72,7 +72,7 @@ describe('SelectEventPlugin', () => {
// Verify that it doesn't get "stuck" waiting for
// a `mouseup` event that it has "missed" because
// a top-level listener didn't exist yet.
expect(select.mock.calls.length).toBe(1);
expect(select).toHaveBeenCalledTimes(1);
});
it('should fire `onSelect` when a listener is present', () => {
@ -95,17 +95,17 @@ describe('SelectEventPlugin', () => {
cancelable: true,
});
node.dispatchEvent(nativeEvent);
expect(select.mock.calls.length).toBe(0);
expect(select).toHaveBeenCalledTimes(0);
nativeEvent = new MouseEvent('mousedown', {
bubbles: true,
cancelable: true,
});
node.dispatchEvent(nativeEvent);
expect(select.mock.calls.length).toBe(0);
expect(select).toHaveBeenCalledTimes(0);
nativeEvent = new MouseEvent('mouseup', {bubbles: true, cancelable: true});
node.dispatchEvent(nativeEvent);
expect(select.mock.calls.length).toBe(1);
expect(select).toHaveBeenCalledTimes(1);
});
});

18
packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js
View File

@ -19,12 +19,12 @@ describe('SimpleEventPlugin', function() {
function expectClickThru(element) {
ReactTestUtils.SimulateNative.click(ReactDOM.findDOMNode(element));
expect(onClick.mock.calls.length).toBe(1);
expect(onClick).toHaveBeenCalledTimes(1);
}
function expectNoClickThru(element) {
ReactTestUtils.SimulateNative.click(ReactDOM.findDOMNode(element));
expect(onClick.mock.calls.length).toBe(0);
expect(onClick).toHaveBeenCalledTimes(0);
}
function mounted(element) {
@ -79,7 +79,7 @@ describe('SimpleEventPlugin', function() {
const child = ReactDOM.findDOMNode(element).firstChild;
ReactTestUtils.SimulateNative.click(child);
expect(onClick.mock.calls.length).toBe(1);
expect(onClick).toHaveBeenCalledTimes(1);
});
it('does not register a click when clicking a child of a disabled element', function() {
@ -91,7 +91,7 @@ describe('SimpleEventPlugin', function() {
const child = ReactDOM.findDOMNode(element).querySelector('span');
ReactTestUtils.SimulateNative.click(child);
expect(onClick.mock.calls.length).toBe(0);
expect(onClick).toHaveBeenCalledTimes(0);
});
it('triggers click events for children of disabled elements', function() {
@ -103,7 +103,7 @@ describe('SimpleEventPlugin', function() {
const child = ReactDOM.findDOMNode(element).querySelector('span');
ReactTestUtils.SimulateNative.click(child);
expect(onClick.mock.calls.length).toBe(1);
expect(onClick).toHaveBeenCalledTimes(1);
});
it('triggers parent captured click events when target is a child of a disabled elements', function() {
@ -117,7 +117,7 @@ describe('SimpleEventPlugin', function() {
const child = ReactDOM.findDOMNode(element).querySelector('span');
ReactTestUtils.SimulateNative.click(child);
expect(onClick.mock.calls.length).toBe(1);
expect(onClick).toHaveBeenCalledTimes(1);
});
it('triggers captured click events for children of disabled elements', function() {
@ -129,7 +129,7 @@ describe('SimpleEventPlugin', function() {
const child = ReactDOM.findDOMNode(element).querySelector('span');
ReactTestUtils.SimulateNative.click(child);
expect(onClick.mock.calls.length).toBe(1);
expect(onClick).toHaveBeenCalledTimes(1);
});
['button', 'input', 'select', 'textarea'].forEach(function(tagName) {
@ -467,7 +467,7 @@ describe('SimpleEventPlugin', function() {
node.dispatchEvent(new MouseEvent('click'));
expect(onClick.mock.calls.length).toBe(0);
expect(onClick).toHaveBeenCalledTimes(0);
});
it('adds a local click listener to non-interactive elements', function() {
@ -479,7 +479,7 @@ describe('SimpleEventPlugin', function() {
node.dispatchEvent(new MouseEvent('click'));
expect(onClick.mock.calls.length).toBe(0);
expect(onClick).toHaveBeenCalledTimes(0);
});
});
});

22
packages/react-native-renderer/src/__tests__/ReactFabric-test.internal.js
View File

@ -56,12 +56,12 @@ describe('ReactFabric', () => {
ReactFabric.render(<View foo="foo" />, 11);
expect(FabricUIManager.createNode.mock.calls.length).toBe(1);
expect(FabricUIManager.createNode).toHaveBeenCalledTimes(1);
ReactFabric.render(<View foo="bar" />, 11);
expect(FabricUIManager.createNode.mock.calls.length).toBe(1);
expect(FabricUIManager.cloneNodeWithNewProps.mock.calls.length).toBe(1);
expect(FabricUIManager.createNode).toHaveBeenCalledTimes(1);
expect(FabricUIManager.cloneNodeWithNewProps).toHaveBeenCalledTimes(1);
expect(FabricUIManager.cloneNodeWithNewProps.mock.calls[0][0]).toBe(
firstNode,
);
@ -93,24 +93,24 @@ describe('ReactFabric', () => {
ReactFabric.render(<Text foo="b">1</Text>, 11);
expect(FabricUIManager.cloneNode).not.toBeCalled();
expect(FabricUIManager.cloneNodeWithNewChildren).not.toBeCalled();
expect(FabricUIManager.cloneNodeWithNewProps.mock.calls.length).toBe(1);
expect(FabricUIManager.cloneNodeWithNewProps).toHaveBeenCalledTimes(1);
expect(FabricUIManager.cloneNodeWithNewChildrenAndProps).not.toBeCalled();
// Only call cloneNode for the changed text (and no other properties).
ReactFabric.render(<Text foo="b">2</Text>, 11);
expect(FabricUIManager.cloneNode).not.toBeCalled();
expect(FabricUIManager.cloneNodeWithNewChildren.mock.calls.length).toBe(1);
expect(FabricUIManager.cloneNodeWithNewProps.mock.calls.length).toBe(1);
expect(FabricUIManager.cloneNodeWithNewChildren).toHaveBeenCalledTimes(1);
expect(FabricUIManager.cloneNodeWithNewProps).toHaveBeenCalledTimes(1);
expect(FabricUIManager.cloneNodeWithNewChildrenAndProps).not.toBeCalled();
// Call cloneNode for both changed text and properties.
ReactFabric.render(<Text foo="c">3</Text>, 11);
expect(FabricUIManager.cloneNode).not.toBeCalled();
expect(FabricUIManager.cloneNodeWithNewChildren.mock.calls.length).toBe(1);
expect(FabricUIManager.cloneNodeWithNewProps.mock.calls.length).toBe(1);
expect(FabricUIManager.cloneNodeWithNewChildren).toHaveBeenCalledTimes(1);
expect(FabricUIManager.cloneNodeWithNewProps).toHaveBeenCalledTimes(1);
expect(
FabricUIManager.cloneNodeWithNewChildrenAndProps.mock.calls.length,
).toBe(1);
FabricUIManager.cloneNodeWithNewChildrenAndProps,
).toHaveBeenCalledTimes(1);
});
it('should only pass props diffs to FabricUIManager.cloneNode', () => {
@ -186,7 +186,7 @@ describe('ReactFabric', () => {
expect(UIManager.updateView).not.toBeCalled();
viewRef.setNativeProps({foo: 'baz'});
expect(UIManager.updateView.mock.calls.length).toBe(1);
expect(UIManager.updateView).toHaveBeenCalledTimes(1);
});
});

12
packages/react-native-renderer/src/__tests__/ReactNativeEvents-test.internal.js
View File

@ -74,14 +74,14 @@ beforeEach(() => {
});
it('fails if unknown/unsupported event types are dispatched', () => {
expect(RCTEventEmitter.register.mock.calls.length).toBe(1);
expect(RCTEventEmitter.register).toHaveBeenCalledTimes(1);
const EventEmitter = RCTEventEmitter.register.mock.calls[0][0];
const View = fakeRequireNativeComponent('View', {});
ReactNative.render(<View onUnspecifiedEvent={() => {}} />, 1);
expect(UIManager.__dumpHierarchyForJestTestsOnly()).toMatchSnapshot();
expect(UIManager.createView.mock.calls.length).toBe(1);
expect(UIManager.createView).toHaveBeenCalledTimes(1);
const target = UIManager.createView.mock.calls[0][0];
@ -95,7 +95,7 @@ it('fails if unknown/unsupported event types are dispatched', () => {
});
it('handles events', () => {
expect(RCTEventEmitter.register.mock.calls.length).toBe(1);
expect(RCTEventEmitter.register).toHaveBeenCalledTimes(1);
const EventEmitter = RCTEventEmitter.register.mock.calls[0][0];
const View = fakeRequireNativeComponent('View', {foo: true});
@ -119,7 +119,7 @@ it('handles events', () => {
);
expect(UIManager.__dumpHierarchyForJestTestsOnly()).toMatchSnapshot();
expect(UIManager.createView.mock.calls.length).toBe(2);
expect(UIManager.createView).toHaveBeenCalledTimes(2);
// Don't depend on the order of createView() calls.
// Stack creates views outside-in; fiber creates them inside-out.
@ -151,7 +151,7 @@ it('handles events', () => {
});
it('handles events on text nodes', () => {
expect(RCTEventEmitter.register.mock.calls.length).toBe(1);
expect(RCTEventEmitter.register).toHaveBeenCalledTimes(1);
const EventEmitter = RCTEventEmitter.register.mock.calls[0][0];
const Text = fakeRequireNativeComponent('RCTText', {});
@ -188,7 +188,7 @@ it('handles events on text nodes', () => {
1,
);
expect(UIManager.createView.mock.calls.length).toBe(5);
expect(UIManager.createView).toHaveBeenCalledTimes(5);
// Don't depend on the order of createView() calls.
// Stack creates views outside-in; fiber creates them inside-out.

16
packages/react-native-renderer/src/__tests__/ReactNativeMount-test.internal.js
View File

@ -47,15 +47,15 @@ describe('ReactNative', () => {
ReactNative.render(<View foo="foo" />, 11);
expect(UIManager.createView.mock.calls.length).toBe(1);
expect(UIManager.setChildren.mock.calls.length).toBe(1);
expect(UIManager.createView).toHaveBeenCalledTimes(1);
expect(UIManager.setChildren).toHaveBeenCalledTimes(1);
expect(UIManager.manageChildren).not.toBeCalled();
expect(UIManager.updateView).not.toBeCalled();
ReactNative.render(<View foo="bar" />, 11);
expect(UIManager.createView.mock.calls.length).toBe(1);
expect(UIManager.setChildren.mock.calls.length).toBe(1);
expect(UIManager.createView).toHaveBeenCalledTimes(1);
expect(UIManager.setChildren).toHaveBeenCalledTimes(1);
expect(UIManager.manageChildren).not.toBeCalled();
expect(UIManager.updateView).toBeCalledWith(3, 'RCTView', {foo: 'bar'});
});
@ -75,15 +75,15 @@ describe('ReactNative', () => {
// Only call updateView for the changed property (and not for text).
ReactNative.render(<Text foo="b">1</Text>, 11);
expect(UIManager.updateView.mock.calls.length).toBe(1);
expect(UIManager.updateView).toHaveBeenCalledTimes(1);
// Only call updateView for the changed text (and no other properties).
ReactNative.render(<Text foo="b">2</Text>, 11);
expect(UIManager.updateView.mock.calls.length).toBe(2);
expect(UIManager.updateView).toHaveBeenCalledTimes(2);
// Call updateView for both changed text and properties.
ReactNative.render(<Text foo="c">3</Text>, 11);
expect(UIManager.updateView.mock.calls.length).toBe(4);
expect(UIManager.updateView).toHaveBeenCalledTimes(4);
});
it('should not call UIManager.updateView from setNativeProps for properties that have not changed', () => {
@ -117,7 +117,7 @@ describe('ReactNative', () => {
expect(UIManager.updateView).not.toBeCalled();
viewRef.setNativeProps({foo: 'baz'});
expect(UIManager.updateView.mock.calls.length).toBe(1);
expect(UIManager.updateView).toHaveBeenCalledTimes(1);
});
});

4
packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
View File

@ -1198,12 +1198,12 @@ describe('ReactIncrementalErrorHandling', () => {
expect(ReactNoop.getChildren()).toEqual([span('Caught an error: oops')]);
if (__DEV__) {
expect(console.error.calls.count()).toBe(1);
expect(console.error).toHaveBeenCalledTimes(1);
expect(console.error.calls.argsFor(0)[0]).toContain(
'The above error occurred in the <BadRender> component:',
);
} else {
expect(console.error.calls.count()).toBe(1);
expect(console.error).toHaveBeenCalledTimes(1);
expect(console.error.calls.argsFor(0)[0]).toBe(notAnError);
}
});

2
packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.internal.js
View File

@ -145,7 +145,7 @@ describe('ReactIncrementalErrorLogging', () => {
expect(logCapturedErrorCalls.length).toBe(1);
// The error thrown in logCapturedError should also be logged
expect(console.error.calls.count()).toBe(1);
expect(console.error).toHaveBeenCalledTimes(1);
expect(console.error.calls.argsFor(0)[0].message).toContain(
'logCapturedError error',
);

2
packages/react-reconciler/src/__tests__/ReactNewContext-test.internal.js
View File

@ -716,7 +716,7 @@ describe('ReactNewContext', () => {
ReactNoop.flush();
if (__DEV__) {
expect(console.error.calls.count()).toBe(1);
expect(console.error).toHaveBeenCalledTimes(1);
expect(console.error.calls.argsFor(0)[0]).toContain(
'calculateChangedBits: Expected the return value to be a 31-bit ' +
'integer. Instead received: 4294967295',

8
packages/react-scheduler/src/__tests__/ReactScheduler-test.js vendored
View File

@ -88,7 +88,7 @@ describe('ReactScheduler', () => {
const cb = jest.fn();
scheduleWork(cb);
advanceOneFrame({timeLeftInFrame: 15});
expect(cb.mock.calls.length).toBe(1);
expect(cb).toHaveBeenCalledTimes(1);
// should not have timed out and should include a timeRemaining method
expect(cb.mock.calls[0][0].didTimeout).toBe(false);
expect(typeof cb.mock.calls[0][0].timeRemaining()).toBe('number');
@ -333,10 +333,10 @@ describe('ReactScheduler', () => {
const {scheduleWork, cancelScheduledWork} = ReactScheduler;
const cb = jest.fn();
const callbackId = scheduleWork(cb);
expect(cb.mock.calls.length).toBe(0);
expect(cb).toHaveBeenCalledTimes(0);
cancelScheduledWork(callbackId);
advanceOneFrame({timeLeftInFrame: 15});
expect(cb.mock.calls.length).toBe(0);
expect(cb).toHaveBeenCalledTimes(0);
});
describe('with multiple callbacks', () => {
@ -356,7 +356,7 @@ describe('ReactScheduler', () => {
advanceOneFrame({timeLeftInFrame: 15});
// B should not get called because A cancelled B
expect(callbackLog).toEqual(['A']);
expect(callbackB.mock.calls.length).toBe(0);
expect(callbackB).toHaveBeenCalledTimes(0);
});
});
});

4
packages/react-test-renderer/src/__tests__/ReactShallowRenderer-test.js vendored
View File

@ -1237,12 +1237,12 @@ describe('ReactShallowRenderer', () => {
shallowRenderer.render(<Component />);
expect(mockFn.mock.calls.length).toBe(2);
expect(mockFn).toHaveBeenCalledTimes(2);
// Ensure the callback queue is cleared after the callbacks are invoked
const mountedInstance = shallowRenderer.getMountedInstance();
mountedInstance.setState({foo: 'bar'}, () => mockFn());
expect(mockFn.mock.calls.length).toBe(3);
expect(mockFn).toHaveBeenCalledTimes(3);
});
it('should call the setState callback even if shouldComponentUpdate = false', done => {

74
packages/react/src/__tests__/ReactChildren-test.js
View File

@ -21,7 +21,7 @@ describe('ReactChildren', () => {
it('should support identity for simple', () => {
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid, index) {
const callback = jest.fn().mockImplementation(function(kid, index) {
expect(this).toBe(context);
return kid;
});
@ -34,7 +34,7 @@ describe('ReactChildren', () => {
const instance = <div>{simpleKid}</div>;
React.Children.forEach(instance.props.children, callback, context);
expect(callback).toHaveBeenCalledWith(simpleKid, 0);
callback.calls.reset();
callback.mockClear();
const mappedChildren = React.Children.map(
instance.props.children,
callback,
@ -46,7 +46,7 @@ describe('ReactChildren', () => {
it('should support Portal components', () => {
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid, index) {
const callback = jest.fn().mockImplementation(function(kid, index) {
expect(this).toBe(context);
return kid;
});
@ -59,7 +59,7 @@ describe('ReactChildren', () => {
const parentInstance = <div>{reactPortal}</div>;
React.Children.forEach(parentInstance.props.children, callback, context);
expect(callback).toHaveBeenCalledWith(reactPortal, 0);
callback.calls.reset();
callback.mockClear();
const mappedChildren = React.Children.map(
parentInstance.props.children,
callback,
@ -71,7 +71,7 @@ describe('ReactChildren', () => {
it('should treat single arrayless child as being in array', () => {
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid, index) {
const callback = jest.fn().mockImplementation(function(kid, index) {
expect(this).toBe(context);
return kid;
});
@ -80,7 +80,7 @@ describe('ReactChildren', () => {
const instance = <div>{simpleKid}</div>;
React.Children.forEach(instance.props.children, callback, context);
expect(callback).toHaveBeenCalledWith(simpleKid, 0);
callback.calls.reset();
callback.mockClear();
const mappedChildren = React.Children.map(
instance.props.children,
callback,
@ -92,7 +92,7 @@ describe('ReactChildren', () => {
it('should treat single child in array as expected', () => {
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid, index) {
const callback = jest.fn().mockImplementation(function(kid, index) {
expect(this).toBe(context);
return kid;
});
@ -101,7 +101,7 @@ describe('ReactChildren', () => {
const instance = <div>{[simpleKid]}</div>;
React.Children.forEach(instance.props.children, callback, context);
expect(callback).toHaveBeenCalledWith(simpleKid, 0);
callback.calls.reset();
callback.mockClear();
const mappedChildren = React.Children.map(
instance.props.children,
callback,
@ -119,7 +119,7 @@ describe('ReactChildren', () => {
const four = <div key="keyFour" />;
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
expect(this).toBe(context);
return kid;
});
@ -140,7 +140,7 @@ describe('ReactChildren', () => {
expect(callback).toHaveBeenCalledWith(two, 2);
expect(callback).toHaveBeenCalledWith(three, 3);
expect(callback).toHaveBeenCalledWith(four, 4);
callback.calls.reset();
callback.mockClear();
}
React.Children.forEach(instance.props.children, callback, context);
@ -165,7 +165,7 @@ describe('ReactChildren', () => {
const a = <a key="aNode" />;
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
expect(this).toBe(context);
return kid;
});
@ -185,7 +185,7 @@ describe('ReactChildren', () => {
);
function assertCalls() {
expect(callback.calls.count()).toBe(9);
expect(callback).toHaveBeenCalledTimes(9);
expect(callback).toHaveBeenCalledWith(div, 0);
expect(callback).toHaveBeenCalledWith(span, 1);
expect(callback).toHaveBeenCalledWith(a, 2);
@ -195,7 +195,7 @@ describe('ReactChildren', () => {
expect(callback).toHaveBeenCalledWith(null, 6);
expect(callback).toHaveBeenCalledWith(null, 7);
expect(callback).toHaveBeenCalledWith(null, 8);
callback.calls.reset();
callback.mockClear();
}
React.Children.forEach(instance.props.children, callback, context);
@ -225,21 +225,21 @@ describe('ReactChildren', () => {
const five = <div key="keyFive" />;
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
return kid;
});
const instance = <div>{[[zero, one, two], [three, four], five]}</div>;
function assertCalls() {
expect(callback.calls.count()).toBe(6);
expect(callback).toHaveBeenCalledTimes(6);
expect(callback).toHaveBeenCalledWith(zero, 0);
expect(callback).toHaveBeenCalledWith(one, 1);
expect(callback).toHaveBeenCalledWith(two, 2);
expect(callback).toHaveBeenCalledWith(three, 3);
expect(callback).toHaveBeenCalledWith(four, 4);
expect(callback).toHaveBeenCalledWith(five, 5);
callback.calls.reset();
callback.mockClear();
}
React.Children.forEach(instance.props.children, callback, context);
@ -263,7 +263,7 @@ describe('ReactChildren', () => {
const zeroForceKey = <div key="keyZero" />;
const oneForceKey = <div key="keyOne" />;
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
expect(this).toBe(context);
return kid;
});
@ -278,7 +278,7 @@ describe('ReactChildren', () => {
function assertCalls() {
expect(callback).toHaveBeenCalledWith(zeroForceKey, 0);
expect(callback).toHaveBeenCalledWith(oneForceKey, 1);
callback.calls.reset();
callback.mockClear();
}
React.Children.forEach(forcedKeys.props.children, callback, context);
@ -313,7 +313,7 @@ describe('ReactChildren', () => {
};
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
expect(this).toBe(context);
return kid;
});
@ -324,11 +324,11 @@ describe('ReactChildren', () => {
);
function assertCalls() {
expect(callback.calls.count()).toBe(3);
expect(callback).toHaveBeenCalledTimes(3);
expect(callback).toHaveBeenCalledWith(<div />, 0);
expect(callback).toHaveBeenCalledWith(<div />, 1);
expect(callback).toHaveBeenCalledWith(<div />, 2);
callback.calls.reset();
callback.mockClear();
}
React.Children.forEach(instance.props.children, callback, context);
@ -364,7 +364,7 @@ describe('ReactChildren', () => {
};
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
expect(this).toBe(context);
return kid;
});
@ -372,11 +372,11 @@ describe('ReactChildren', () => {
const instance = <div>{threeDivIterable}</div>;
function assertCalls() {
expect(callback.calls.count()).toBe(3);
expect(callback).toHaveBeenCalledTimes(3);
expect(callback).toHaveBeenCalledWith(<div key="#1" />, 0);
expect(callback).toHaveBeenCalledWith(<div key="#2" />, 1);
expect(callback).toHaveBeenCalledWith(<div key="#3" />, 2);
callback.calls.reset();
callback.mockClear();
}
React.Children.forEach(instance.props.children, callback, context);
@ -412,17 +412,17 @@ describe('ReactChildren', () => {
);
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
expect(this).toBe(context);
return kid;
});
const assertCalls = function() {
expect(callback.calls.count()).toBe(3);
expect(callback).toHaveBeenCalledTimes(3);
expect(callback).toHaveBeenCalledWith(5, 0);
expect(callback).toHaveBeenCalledWith(12, 1);
expect(callback).toHaveBeenCalledWith(13, 2);
callback.calls.reset();
callback.mockClear();
};
React.Children.forEach(instance.props.children, callback, context);
@ -454,16 +454,16 @@ describe('ReactChildren', () => {
);
const context = {};
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
expect(this).toBe(context);
return kid;
});
function assertCalls() {
expect(callback.calls.count()).toBe(2, 0);
expect(callback).toHaveBeenCalledTimes(2, 0);
expect(callback).toHaveBeenCalledWith('a', 0);
expect(callback).toHaveBeenCalledWith(13, 1);
callback.calls.reset();
callback.mockClear();
}
React.Children.forEach(instance.props.children, callback, context);
@ -536,7 +536,7 @@ describe('ReactChildren', () => {
<span />, // Map from null to something.
<div key="keyFour" />,
];
const callback = jasmine.createSpy().and.callFake(function(kid, index) {
const callback = jest.fn().mockImplementation(function(kid, index) {
return mapped[index];
});
@ -556,13 +556,13 @@ describe('ReactChildren', () => {
expect(callback).toHaveBeenCalledWith(two, 2);
expect(callback).toHaveBeenCalledWith(three, 3);
expect(callback).toHaveBeenCalledWith(four, 4);
callback.calls.reset();
callback.mockClear();
const mappedChildren = React.Children.map(
instance.props.children,
callback,
);
expect(callback.calls.count()).toBe(5);
expect(callback).toHaveBeenCalledTimes(5);
expect(React.Children.count(mappedChildren)).toBe(4);
// Keys default to indices.
expect([
@ -597,7 +597,7 @@ describe('ReactChildren', () => {
const fourMapped = <div key="keyFour" />;
const fiveMapped = <div />;
const callback = jasmine.createSpy().and.callFake(function(kid) {
const callback = jest.fn().mockImplementation(function(kid) {
switch (kid) {
case zero:
return zeroMapped;
@ -616,20 +616,20 @@ describe('ReactChildren', () => {
const instance = <div>{[frag]}</div>;
React.Children.forEach(instance.props.children, callback);
expect(callback.calls.count()).toBe(6);
expect(callback).toHaveBeenCalledTimes(6);
expect(callback).toHaveBeenCalledWith(zero, 0);
expect(callback).toHaveBeenCalledWith(one, 1);
expect(callback).toHaveBeenCalledWith(two, 2);
expect(callback).toHaveBeenCalledWith(three, 3);
expect(callback).toHaveBeenCalledWith(four, 4);
expect(callback).toHaveBeenCalledWith(five, 5);
callback.calls.reset();
callback.mockClear();
const mappedChildren = React.Children.map(
instance.props.children,
callback,
);
expect(callback.calls.count()).toBe(6);
expect(callback).toHaveBeenCalledTimes(6);
expect(callback).toHaveBeenCalledWith(zero, 0);
expect(callback).toHaveBeenCalledWith(one, 1);
expect(callback).toHaveBeenCalledWith(two, 2);

11
scripts/jest/matchers/toWarnDev.js
View File

@ -2,13 +2,6 @@
const jestDiff = require('jest-diff');
function diffString(a, b) {
// jest-diff does not currently handle single line strings correctly
// The easiest work around is to ensure that both strings are multiline
// https://github.com/facebook/jest/issues/5657
return jestDiff(a + '\n', b + '\n');
}
function normalizeCodeLocInfo(str) {
return str && str.replace(/at .+?:\d+/g, 'at **');
}
@ -56,11 +49,11 @@ const createMatcherFor = consoleMethod =>
} else if (expectedMessages.length === 1) {
errorMessage =
'Unexpected warning recorded: ' +
diffString(normalizedMessage, expectedMessages[0]);
jestDiff(normalizedMessage, expectedMessages[0]);
} else {
errorMessage =
'Unexpected warning recorded: ' +
diffString([normalizedMessage], expectedMessages);
jestDiff([normalizedMessage], expectedMessages);
}
// Record the call stack for unexpected warnings.

1002
yarn.lock
View File

File diff suppressed because it is too large Load Diff