Merge branch 'master' into aymericbouzy

Author: aymericbouzy

.prettierignore

@@ -0,0 +1 @@
+package.json

CHANGELOG.md

@@ -16,9 +16,19 @@
   ([#5670](https://github.com/facebook/jest/pull/5670))
 * `[expect]` Add inverse matchers (`expect.not.arrayContaining`, etc.,
   [#5517](https://github.com/facebook/jest/pull/5517))
+* `[jest-mock]` Add tracking of return values in the `mock` property
+  ([#5738](https://github.com/facebook/jest/issues/5738))
+* `[expect]`Add nthCalledWith spy matcher
+  ([#5605](https://github.com/facebook/jest/pull/5605))
+* `[jest-cli]` Add `isSerial` property that runners can expose to specify that
+  they can not run in parallel
+  [#5706](https://github.com/facebook/jest/pull/5706)
 
 ### Fixes
 
+* `[expect]` Do not rely on `instanceof RegExp`, since it will not work for
+  RegExps created inside of a different VM
+  ([#5729](https://github.com/facebook/jest/pull/5729))
 * `[jest-resolve]` Update node module resolution algorithm to correctly handle
   symlinked paths ([#5085](https://github.com/facebook/jest/pull/5085))
 * `[jest-editor-support]` Update `Settings` to use spawn in shell option
@@ -42,6 +52,12 @@
   ([#5648](https://github.com/facebook/jest/pull/5708))
 * `[docs]` Add docs on using `jest.mock(...)`
   ([#5648](https://github.com/facebook/jest/pull/5648))
+* `[docs]` Mention Jest Puppeteer Preset
+  ([#5722](https://github.com/facebook/jest/pull/5722))
+* `[docs]` Add jest-community section to website
+  ([#5675](https://github.com/facebook/jest/pull/5675))
+* `[docs]` Add versioned docs for v22.4
+  ([##5733](https://github.com/facebook/jest/pull/#5733))
 
 ## 22.4.2
 

docs/Configuration.md

@@ -123,6 +123,14 @@ Jest attempts to scan your dependency tree once (up-front) and cache it in order
 to ease some of the filesystem raking that needs to happen while running tests.
 This config option lets you customize where Jest stores that cache data on disk.
 
+### `clearMocks` [boolean]
+
+Default: `false`
+
+Automatically clear mock calls and instances between every test. Equivalent to
+calling `jest.clearAllMocks()` between each test. This does not remove any mock
+implementation that may have been provided.
+
 ### `collectCoverage` [boolean]
 
 Default: `false`
@@ -494,14 +502,6 @@ _Note: When using multi project runner, it's recommended to add a `displayName`
 for each project. This will show the `displayName` of a project next to its
 tests._
 
-### `clearMocks` [boolean]
-
-Default: `false`
-
-Automatically clear mock calls and instances between every test. Equivalent to
-calling `jest.clearAllMocks()` between each test. This does not remove any mock
-implementation that may have been provided.
-
 ### `reporters` [array<moduleName | [moduleName, options]>]
 
 Default: `undefined`
@@ -703,6 +703,10 @@ async runTests(
 ): Promise<void>
 ```
 
+If you need to restrict your test-runner to only run in serial rather then being
+executed in parallel your class should have the property `isSerial` to be set as
+`true`.
+
 ### `setupFiles` [array]
 
 Default: `[]`
@@ -889,7 +893,7 @@ given to [jsdom](https://github.com/tmpvar/jsdom) such as
 
 ##### available in Jest **19.0.0+**
 
-(default: `[ '**/__tests__/**/*.js?(x)', '**/?(*.)(spec|test).js?(x)' ]`)
+(default: `[ '**/__tests__/**/*.js?(x)', '**/?(*.)+(spec|test).js?(x)' ]`)
 
 The glob patterns Jest uses to detect test files. By default it looks for `.js`
 and `.jsx` files inside of `__tests__` folders, as well as any files with a

docs/ExpectAPI.md

@@ -622,6 +622,25 @@ test('applying to all flavors does mango last', () => {
 });
 ```
 
+### `.nthCalledWith(nthCall, arg1, arg2, ....)`
+
+If you have a mock function, you can use `.nthCalledWith` to test what arguments
+it was nth called with. For example, let's say you have a
+`drinkEach(drink, Array<flavor>)` function that applies `f` to a bunch of
+flavors, and you want to ensure that when you call it, the first flavor it
+operates on is `'lemon'` and the second one is `'octopus'`. You can write:
+
+Note that, nth argument must be positive integer starting from 1.
+
+```js
+test('drinkEach drinks each drink', () => {
+  const drink = jest.fn();
+  drinkEach(drink, ['lemon', 'octopus']);
+  expect(drink).nthCalledWith(1, 'lemon');
+  expect(drink).nthCalledWith(2, 'octopus');
+});
+```
+
 ### `.toBeCloseTo(number, numDigits)`
 
 Using exact equality with floating point numbers is a bad idea. Rounding means

docs/ManualMocks.md

@@ -53,8 +53,9 @@ accordingly.
 ```
 
 When a manual mock exists for a given module, Jest's module system will use that
-module when explicitly calling `jest.mock('moduleName')`. However, manual mocks
-will take precedence over node modules even if `jest.mock('moduleName')` is not
+module when explicitly calling `jest.mock('moduleName')`. However, when
+`automock` is set to `true`, the manual mock implementation will be used instead
+of the automatically created mock, even if `jest.mock('moduleName')` is not
 called. To opt out of this behavior you will need to explicitly call
 `jest.unmock('moduleName')` in tests that should use the actual module
 implementation.

docs/MockFunctionAPI.md

@@ -29,13 +29,26 @@ Each call is represented by an array of arguments that were passed during the
 call.
 
 For example: A mock function `f` that has been called twice, with the arguments
-`f('arg1', 'arg2')`, and then with the arguments `f('arg3', 'arg4')` would have
+`f('arg1', 'arg2')`, and then with the arguments `f('arg3', 'arg4')`, would have
 a `mock.calls` array that looks like this:
 
 ```js
 [['arg1', 'arg2'], ['arg3', 'arg4']];
 ```
 
+### `mockFn.mock.returnValues`
+
+An array containing values that have been returned by all calls to this mock
+function.
+
+For example: A mock function `f` that has been called twice, returning
+`result1`, and then returning `result2`, would have a `mock.returnValues` array
+that looks like this:
+
+```js
+['result1', 'result2'];
+```
+
 ### `mockFn.mock.instances`
 
 An array that contains all the object instances that have been instantiated from

docs/MockFunctions.md

@@ -41,13 +41,17 @@ expect(mockCallback.mock.calls[0][0]).toBe(0);
 
 // The first argument of the second call to the function was 1
 expect(mockCallback.mock.calls[1][0]).toBe(1);
+
+// The return value of the first call to the function was 42
+expect(mockCallback.mock.returnValues[0]).toBe(42);
 ```
 
 ## `.mock` property
 
 All mock functions have this special `.mock` property, which is where data about
-how the function has been called is kept. The `.mock` property also tracks the
-value of `this` for each call, so it is possible to inspect this as well:
+how the function has been called and what the function returned is kept. The
+`.mock` property also tracks the value of `this` for each call, so it is
+possible to inspect this as well:
 
 ```javascript
 const myMock = jest.fn();
@@ -62,7 +66,7 @@ console.log(myMock.mock.instances);
 ```
 
 These mock members are very useful in tests to assert how these functions get
-called, or instantiated:
+called, instantiated, or what they returned:
 
 ```javascript
 // The function was called exactly once
@@ -74,6 +78,9 @@ expect(someMockFunction.mock.calls[0][0]).toBe('first arg');
 // The second arg of the first call to the function was 'second arg'
 expect(someMockFunction.mock.calls[0][1]).toBe('second arg');
 
+// The return value of the first call to the function was 'return value'
+expect(someMockFunction.mock.returnValues[0]).toBe('return value');
+
 // This function was instantiated exactly twice
 expect(someMockFunction.mock.instances.length).toBe(2);
 
@@ -165,7 +172,7 @@ test('should fetch users', () => {
   const resp = {data: [{name: 'Bob'}]};
   axios.get.mockResolvedValue(resp);
 
-  // or you could use the follwing depending on your use case:
+  // or you could use the following depending on your use case:
   // axios.get.mockImpementation(() => Promise.resolve(resp))
 
   return Users.all().then(users => expect(users).toEqual(resp.data));

docs/Puppeteer.md

@@ -7,7 +7,28 @@ With the [Global Setup/Teardown](Configuration.md#globalsetup-string) and
 [Async Test Environment](Configuration.md#testenvironment-string) APIs, Jest can
 work smoothly with [puppeteer](https://github.com/GoogleChrome/puppeteer).
 
-## A jest-puppeteer example
+## Use Puppeteer Preset
+
+[Jest Puppeteer Preset](https://github.com/smooth-code/jest-puppeteer) provides
+all required configuration to run your tests using Puppeteer.
+
+1.  First install `jest-puppeteer-preset`
+
+```
+yarn add --dev jest-puppeteer-preset
+```
+
+2.  Specify preset in your Jest configuration:
+
+```json
+{
+  "preset": "jest-puppeteer-preset"
+}
+```
+
+See [documentation](https://github.com/smooth-code/jest-puppeteer).
+
+## Custom example
 
 The basic idea is to:
 

docs/TestingFrameworks.md

@@ -34,5 +34,4 @@ about integrating Jest into other popular JS libraries.
 
 ## Redux
 
-* [Writing Tests](http://redux.js.org/docs/recipes/WritingTests.html) by Redux
-  docs
+* [Writing Tests](https://redux.js.org/recipes/writing-tests) by Redux docs

examples/typescript/package.json

@@ -17,6 +17,6 @@
     "transform": {
       "^.+\\.(ts|tsx)$": "<rootDir>/preprocessor.js"
     },
-    "testMatch": ["**/__tests__/*.(ts|tsx|js)"]
+    "testMatch": ["**/__tests__/*.+(ts|tsx|js)"]
   }
 }