eslint-plugin-jest 23.20.0 → 24.1.0

package/CHANGELOG.md

@@ -1,3 +1,64 @@
+# [24.1.0](https://github.com/jest-community/eslint-plugin-jest/compare/v24.0.2...v24.1.0) (2020-10-05)
+
+
+### Features
+
+* **prefer-expect-assertions:** add `onlyFunctionsWithAsyncKeyword` option ([#677](https://github.com/jest-community/eslint-plugin-jest/issues/677)) ([d0cea37](https://github.com/jest-community/eslint-plugin-jest/commit/d0cea37ae0a8ab07b8082cedbaaf161bcc94c405))
+
+## [24.0.2](https://github.com/jest-community/eslint-plugin-jest/compare/v24.0.1...v24.0.2) (2020-09-20)
+
+
+### Bug Fixes
+
+* **no-if:** check both types of function expression ([#672](https://github.com/jest-community/eslint-plugin-jest/issues/672)) ([d462d50](https://github.com/jest-community/eslint-plugin-jest/commit/d462d50aed84ad4dc536a1f47bb7af6abd3dbe92)), closes [#670](https://github.com/jest-community/eslint-plugin-jest/issues/670)
+
+## [24.0.1](https://github.com/jest-community/eslint-plugin-jest/compare/v24.0.0...v24.0.1) (2020-09-12)
+
+
+### Bug Fixes
+
+* don't include deprecated rules in `all` config ([#664](https://github.com/jest-community/eslint-plugin-jest/issues/664)) ([f636021](https://github.com/jest-community/eslint-plugin-jest/commit/f636021c16215a713845c699858a2978211df49d)), closes [#663](https://github.com/jest-community/eslint-plugin-jest/issues/663)
+
+# [24.0.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.20.0...v24.0.0) (2020-09-04)
+
+
+### Bug Fixes
+
+* **no-large-snapshots:** run on all files regardless of type ([#637](https://github.com/jest-community/eslint-plugin-jest/issues/637)) ([22113db](https://github.com/jest-community/eslint-plugin-jest/commit/22113db4cdc2dab42a8e7fdb236d23e7e089741d)), closes [#370](https://github.com/jest-community/eslint-plugin-jest/issues/370)
+* remove Jasmine globals ([#596](https://github.com/jest-community/eslint-plugin-jest/issues/596)) ([a0e2bc5](https://github.com/jest-community/eslint-plugin-jest/commit/a0e2bc526c5c22bcf4d60160242b55d03edb571d))
+* update to typescript-eslint@4 ([1755965](https://github.com/jest-community/eslint-plugin-jest/commit/175596582b3643f36363ff444f987fac08ee0f61)), closes [#590](https://github.com/jest-community/eslint-plugin-jest/issues/590)
+
+
+### Code Refactoring
+
+* **no-test-callback:** rename rule to `no-done-callback` ([#653](https://github.com/jest-community/eslint-plugin-jest/issues/653)) ([e15a8d1](https://github.com/jest-community/eslint-plugin-jest/commit/e15a8d19234b267784f87fc7acd318dc4cfcdeae))
+
+
+### Features
+
+* **no-done-callback:** support hooks ([#656](https://github.com/jest-community/eslint-plugin-jest/issues/656)) ([3e6cb44](https://github.com/jest-community/eslint-plugin-jest/commit/3e6cb442a20b9aea710d30f81bf2eb192d193823)), closes [#649](https://github.com/jest-community/eslint-plugin-jest/issues/649) [#651](https://github.com/jest-community/eslint-plugin-jest/issues/651)
+* add `no-conditional-expect` to the recommended ruleset ([40cd89d](https://github.com/jest-community/eslint-plugin-jest/commit/40cd89ddf1d6ebbde8ad455f333dda7b61878ffe))
+* add `no-deprecated-functions` to the recommended ruleset ([5b2af00](https://github.com/jest-community/eslint-plugin-jest/commit/5b2af001b50059e4e7b6ababe0355d664e039046))
+* add `no-interpolation-in-snapshots` to the recommended ruleset ([3705dff](https://github.com/jest-community/eslint-plugin-jest/commit/3705dff9d4f77d21013e263478d8a374d9325acb))
+* add `valid-title` to recommended ruleset ([41f7873](https://github.com/jest-community/eslint-plugin-jest/commit/41f7873f734e0122264ace42f6d99733e7e25089))
+* drop support for node 8 ([#570](https://github.com/jest-community/eslint-plugin-jest/issues/570)) ([6788e72](https://github.com/jest-community/eslint-plugin-jest/commit/6788e72d842751400a970e72b115360ad0b12d2e))
+* set `no-jasmine-globals` to `error` in recommended ruleset ([7080952](https://github.com/jest-community/eslint-plugin-jest/commit/7080952a6baaae7a02c78f60016ee21693121416))
+* **no-large-snapshots:** remove `whitelistedSnapshots` option ([8c1c0c9](https://github.com/jest-community/eslint-plugin-jest/commit/8c1c0c9a3e858757b38225ccb4a624e0621b5ca2))
+
+
+### BREAKING CHANGES
+
+* **no-done-callback:** `no-done-callback` will now report hooks using callbacks as well, not just tests
+* **no-test-callback:** rename `no-test-callback` to `no-done-callback`
+* recommend `no-conditional-expect` rule
+* recommend `no-interpolation-in-snapshots` rule
+* recommend `no-deprecated-functions` rule
+* recommend `valid-title` rule
+* recommend erroring for `no-jasmine-globals` rule
+* **no-large-snapshots:** `no-large-snapshots` runs on all files regardless of type 
+* Jasmine globals are no marked as such
+* Node 10+ required
+
 # [23.20.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.19.0...v23.20.0) (2020-07-30)
 
 

package/README.md

@@ -57,6 +57,9 @@ doing:
 }
 ```
 
+This is included in all configs shared by this plugin, so can be omitted if
+extending them.
+
 The behaviour of some rules (specifically `no-deprecated-functions`) change
 depending on the version of `jest` being used.
 
@@ -135,23 +138,23 @@ installations requiring long-term consistency.
 | [lowercase-name](docs/rules/lowercase-name.md)                               | Enforce lowercase test names                                    |                  | ![fixable][] |
 | [no-alias-methods](docs/rules/no-alias-methods.md)                           | Disallow alias methods                                          | ![style][]       | ![fixable][] |
 | [no-commented-out-tests](docs/rules/no-commented-out-tests.md)               | Disallow commented out tests                                    | ![recommended][] |              |
-| [no-conditional-expect](docs/rules/no-conditional-expect.md)                 | Prevent calling `expect` conditionally                          |                  |              |
-| [no-deprecated-functions](docs/rules/no-deprecated-functions.md)             | Disallow use of deprecated functions                            |                  | ![fixable][] |
+| [no-conditional-expect](docs/rules/no-conditional-expect.md)                 | Prevent calling `expect` conditionally                          | ![recommended][] |              |
+| [no-deprecated-functions](docs/rules/no-deprecated-functions.md)             | Disallow use of deprecated functions                            | ![recommended][] | ![fixable][] |
 | [no-disabled-tests](docs/rules/no-disabled-tests.md)                         | Disallow disabled tests                                         | ![recommended][] |              |
+| [no-done-callback](docs/rules/no-done-callback.md)                           | Avoid using a callback in asynchronous tests and hooks          | ![recommended][] | ![suggest][] |
 | [no-duplicate-hooks](docs/rules/no-duplicate-hooks.md)                       | Disallow duplicate setup and teardown hooks                     |                  |              |
 | [no-export](docs/rules/no-export.md)                                         | Disallow using `exports` in files containing tests              | ![recommended][] |              |
 | [no-focused-tests](docs/rules/no-focused-tests.md)                           | Disallow focused tests                                          | ![recommended][] | ![fixable][] |
 | [no-hooks](docs/rules/no-hooks.md)                                           | Disallow setup and teardown hooks                               |                  |              |
 | [no-identical-title](docs/rules/no-identical-title.md)                       | Disallow identical titles                                       | ![recommended][] |              |
 | [no-if](docs/rules/no-if.md)                                                 | Disallow conditional logic                                      |                  |              |
-| [no-interpolation-in-snapshots](docs/rules/no-interpolation-in-snapshots.md) | Disallow string interpolation inside snapshots                  |                  |              |
+| [no-interpolation-in-snapshots](docs/rules/no-interpolation-in-snapshots.md) | Disallow string interpolation inside snapshots                  | ![recommended][] |              |
 | [no-jasmine-globals](docs/rules/no-jasmine-globals.md)                       | Disallow Jasmine globals                                        | ![recommended][] | ![fixable][] |
 | [no-jest-import](docs/rules/no-jest-import.md)                               | Disallow importing Jest                                         | ![recommended][] |              |
 | [no-large-snapshots](docs/rules/no-large-snapshots.md)                       | disallow large snapshots                                        |                  |              |
 | [no-mocks-import](docs/rules/no-mocks-import.md)                             | Disallow manually importing from `__mocks__`                    | ![recommended][] |              |
 | [no-restricted-matchers](docs/rules/no-restricted-matchers.md)               | Disallow specific matchers & modifiers                          |                  |              |
 | [no-standalone-expect](docs/rules/no-standalone-expect.md)                   | Disallow using `expect` outside of `it` or `test` blocks        | ![recommended][] |              |
-| [no-test-callback](docs/rules/no-test-callback.md)                           | Avoid using a callback in asynchronous tests                    | ![recommended][] | ![suggest][] |
 | [no-test-prefixes](docs/rules/no-test-prefixes.md)                           | Use `.only` and `.skip` over `f` and `x`                        | ![recommended][] | ![fixable][] |
 | [no-test-return-statement](docs/rules/no-test-return-statement.md)           | Disallow explicitly returning from tests                        |                  |              |
 | [prefer-called-with](docs/rules/prefer-called-with.md)                       | Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`    |                  |              |
@@ -169,7 +172,7 @@ installations requiring long-term consistency.
 | [valid-describe](docs/rules/valid-describe.md)                               | Enforce valid `describe()` callback                             | ![recommended][] |              |
 | [valid-expect](docs/rules/valid-expect.md)                                   | Enforce valid `expect()` usage                                  | ![recommended][] |              |
 | [valid-expect-in-promise](docs/rules/valid-expect-in-promise.md)             | Enforce having return statement when testing with promises      | ![recommended][] |              |
-| [valid-title](docs/rules/valid-title.md)                                     | Enforce valid titles                                            |                  | ![fixable][] |
+| [valid-title](docs/rules/valid-title.md)                                     | Enforce valid titles                                            | ![recommended][] | ![fixable][] |
 
 <!-- end rules list -->
 

package/docs/rules/consistent-test-it.md

@@ -59,12 +59,12 @@ test.only('foo'); // invalid
 /*eslint jest/consistent-test-it: ["error", {"fn": "it", "withinDescribe": "test"}]*/
 
 it('foo'); // valid
-describe('foo', function() {
+describe('foo', function () {
   test('bar'); // valid
 });
 
 test('foo'); // invalid
-describe('foo', function() {
+describe('foo', function () {
   it('bar'); // invalid
 });
 ```
@@ -78,12 +78,12 @@ nested within `describe` to use `it`.
 /*eslint jest/consistent-test-it: ["error"]*/
 
 test('foo'); // valid
-describe('foo', function() {
+describe('foo', function () {
   it('bar'); // valid
 });
 
 it('foo'); // invalid
-describe('foo', function() {
+describe('foo', function () {
   test('bar'); // invalid
 });
 ```

package/docs/rules/expect-expect.md

@@ -56,9 +56,7 @@ import { expectSaga } from 'redux-saga-test-plan';
 import { addSaga } from '../src/sagas';
 
 test('returns sum', () => {
-  expectSaga(addSaga, 1, 1)
-    .returns(2)
-    .run();
+  expectSaga(addSaga, 1, 1).returns(2).run();
 });
 ```
 
@@ -72,9 +70,7 @@ import { expectSaga } from 'redux-saga-test-plan';
 import { addSaga } from '../src/sagas';
 
 test('returns sum', () => {
-  expectSaga(addSaga, 1, 1)
-    .returns(2)
-    .run();
+  expectSaga(addSaga, 1, 1).returns(2).run();
 });
 ```
 
@@ -100,12 +96,9 @@ const express = require('express');
 
 const app = express();
 
-describe('GET /user', function() {
-  it('responds with json', function(done) {
-    request(app)
-      .get('/user')
-      .expect('Content-Type', /json/)
-      .expect(200, done);
+describe('GET /user', function () {
+  it('responds with json', function (done) {
+    request(app).get('/user').expect('Content-Type', /json/).expect(200, done);
   });
 });
 ```

package/docs/rules/no-done-callback.md

@@ -0,0 +1,90 @@
+# Avoid using a callback in asynchronous tests and hooks (`no-done-callback`)
+
+When calling asynchronous code in hooks and tests, `jest` needs to know when the
+asynchronous work is complete to progress the current run.
+
+Originally the most common pattern to archive this was to use callbacks:
+
+```js
+test('the data is peanut butter', done => {
+  function callback(data) {
+    try {
+      expect(data).toBe('peanut butter');
+      done();
+    } catch (error) {
+      done(error);
+    }
+  }
+
+  fetchData(callback);
+});
+```
+
+This can be very error prone however, as it requires careful understanding of
+how assertions work in tests or otherwise tests won't behave as expected.
+
+For example, if the `try/catch` was left out of the above code, the test would
+timeout rather than fail. Even with the `try/catch`, forgetting to pass the
+caught error to `done` will result in `jest` believing the test has passed.
+
+A more straightforward way to handle asynchronous code is to use Promises:
+
+```js
+test('the data is peanut butter', () => {
+  return fetchData().then(data => {
+    expect(data).toBe('peanut butter');
+  });
+});
+```
+
+When a test or hook returns a promise, `jest` waits for that promise to resolve,
+as well as automatically failing should the promise reject.
+
+If your environment supports `async/await`, this becomes even simpler:
+
+```js
+test('the data is peanut butter', async () => {
+  const data = await fetchData();
+  expect(data).toBe('peanut butter');
+});
+```
+
+## Rule details
+
+This rule checks the function parameter of hooks & tests for use of the `done`
+argument, suggesting you return a promise instead.
+
+The following patterns are considered warnings:
+
+```js
+beforeEach(done => {
+  // ...
+});
+
+test('myFunction()', done => {
+  // ...
+});
+
+test('myFunction()', function (done) {
+  // ...
+});
+```
+
+The following patterns are not considered warnings:
+
+```js
+beforeEach(async () => {
+  await setupUsTheBomb();
+});
+
+test('myFunction()', () => {
+  expect(myFunction()).toBeTruthy();
+});
+
+test('myFunction()', () => {
+  return new Promise(done => {
+    expect(myFunction()).toBeTruthy();
+    done();
+  });
+});
+```

package/docs/rules/no-export.md

@@ -15,7 +15,7 @@ Examples of **incorrect** code for this rule:
 ```js
 export function myHelper() {}
 
-module.exports = function() {};
+module.exports = function () {};
 
 module.exports = {
   something: 'that should be moved to a non-test file',

package/docs/rules/no-test-return-statement.md

@@ -15,7 +15,7 @@ body.
 
 // valid:
 
-it('noop', function() {});
+it('noop', function () {});
 
 test('noop', () => {});
 
@@ -27,7 +27,7 @@ test('one', () => {
   expect(1).toBe(1);
 });
 
-it('one', function() {
+it('one', function () {
   expect(1).toBe(1);
 });
 
@@ -41,7 +41,7 @@ test('return an expect', () => {
   return expect(1).toBe(1);
 });
 
-it('returning a promise', function() {
+it('returning a promise', function () {
   return new Promise(res => setTimeout(res, 100)).then(() => expect(1).toBe(1));
 });
 ```

package/docs/rules/prefer-expect-assertions.md

@@ -55,3 +55,45 @@ test('my test', () => {
   expect(someThing()).toEqual('foo');
 });
 ```
+
+## Options
+
+#### `onlyFunctionsWithAsyncKeyword`
+
+When `true`, this rule will only warn for tests that use the `async` keyword.
+
+```json
+{
+  "rules": {
+    "jest/prefer-expect-assertions": [
+      "warn",
+      { "onlyFunctionsWithAsyncKeyword": true }
+    ]
+  }
+}
+```
+
+When `onlyFunctionsWithAsyncKeyword` option is set to `true`, the following
+pattern would be a warning:
+
+```js
+test('my test', async () => {
+  const result = await someAsyncFunc();
+  expect(result).toBe('foo');
+});
+```
+
+While the following patterns would not be considered warnings:
+
+```js
+test('my test', () => {
+  const result = someFunction();
+  expect(result).toBe('foo');
+});
+
+test('my test', async () => {
+  expect.assertions(1);
+  const result = await someAsyncFunc();
+  expect(result).toBe('foo');
+});
+```

package/docs/rules/valid-title.md

@@ -55,7 +55,7 @@ it(123, () => {});
 describe(String(/.+/), () => {});
 describe(myFunction, () => {});
 xdescribe(myFunction, () => {});
-describe(6, function() {});
+describe(6, function () {});
 ```
 
 Examples of **correct** code for this rule:
@@ -82,7 +82,7 @@ fdescribe('is a string', () => {});
 describe(String(/.+/), () => {});
 describe(myFunction, () => {});
 xdescribe(myFunction, () => {});
-describe(6, function() {});
+describe(6, function () {});
 ```
 
 **duplicatePrefix**

package/lib/globals.json

@@ -5,14 +5,9 @@
   "beforeEach": false,
   "describe": false,
   "expect": false,
-  "fail": false,
   "fit": false,
   "it": false,
-  "jasmine": false,
   "jest": false,
-  "pending": false,
-  "pit": false,
-  "require": false,
   "test": false,
   "xdescribe": false,
   "xit": false,

package/lib/index.js

@@ -14,12 +14,6 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 // copied from https://github.com/babel/babel/blob/d8da63c929f2d28c401571e2a43166678c555bc4/packages/babel-helpers/src/helpers.js#L602-L606
 
 /* istanbul ignore next */
@@ -32,14 +26,14 @@ interopRequireDefault(require(moduleName)).default;
 
 const rulesDir = (0, _path.join)(__dirname, 'rules');
 const excludedFiles = ['__tests__', 'utils'];
-const rules = (0, _fs.readdirSync)(rulesDir).map(rule => (0, _path.parse)(rule).name).filter(rule => !excludedFiles.includes(rule)).reduce((acc, curr) => _objectSpread(_objectSpread({}, acc), {}, {
+const rules = (0, _fs.readdirSync)(rulesDir).map(rule => (0, _path.parse)(rule).name).filter(rule => !excludedFiles.includes(rule)).reduce((acc, curr) => ({ ...acc,
   [curr]: importDefault((0, _path.join)(rulesDir, curr))
 }), {});
-const recommendedRules = Object.entries(rules).filter(([, rule]) => rule.meta.docs.recommended).reduce((acc, [name, rule]) => _objectSpread(_objectSpread({}, acc), {}, {
+const recommendedRules = Object.entries(rules).filter(([, rule]) => rule.meta.docs.recommended).reduce((acc, [name, rule]) => ({ ...acc,
   [`jest/${name}`]: rule.meta.docs.recommended
 }), {});
-const allRules = Object.keys(rules).reduce((rules, key) => _objectSpread(_objectSpread({}, rules), {}, {
-  [`jest/${key}`]: 'error'
+const allRules = Object.entries(rules).filter(([, rule]) => !rule.meta.deprecated).reduce((acc, [name]) => ({ ...acc,
+  [`jest/${name}`]: 'error'
 }), {});
 
 const createConfig = rules => ({

package/lib/rules/no-conditional-expect.js

@@ -13,7 +13,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       description: 'Prevent calling `expect` conditionally',
       category: 'Best Practices',
-      recommended: false
+      recommended: 'error'
     },
     messages: {
       conditionalExpect: 'Avoid calling `expect` conditionally`'

package/lib/rules/no-deprecated-functions.js

@@ -9,12 +9,6 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 let cachedJestVersion = null;
 /** @internal */
 
@@ -39,7 +33,7 @@ const detectJestVersion = () => {
       const [majorVersion] = jestPackageJson.version.split('.');
       return cachedJestVersion = parseInt(majorVersion, 10);
     }
-  } catch (_unused) {}
+  } catch {}
 
   throw new Error('Unable to detect Jest version - please ensure jest package is installed, or otherwise set version explicitly');
 };
@@ -50,7 +44,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow use of deprecated functions',
-      recommended: false
+      recommended: 'error'
     },
     messages: {
       deprecatedFunction: '`{{ deprecation }}` has been deprecated in favor of `{{ replacement }}`'
@@ -62,23 +56,26 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
 
   create(context) {
-    var _ref, _ref$jest;
-
-    const jestVersion = ((_ref = context.settings) === null || _ref === void 0 ? void 0 : (_ref$jest = _ref.jest) === null || _ref$jest === void 0 ? void 0 : _ref$jest.version) || detectJestVersion();
-
-    const deprecations = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, jestVersion >= 15 && {
-      'jest.resetModuleRegistry': 'jest.resetModules'
-    }), jestVersion >= 17 && {
-      'jest.addMatchers': 'expect.extend'
-    }), jestVersion >= 21 && {
-      'require.requireMock': 'jest.requireMock',
-      'require.requireActual': 'jest.requireActual'
-    }), jestVersion >= 22 && {
-      'jest.runTimersToTime': 'jest.advanceTimersByTime'
-    }), jestVersion >= 26 && {
-      'jest.genMockFromModule': 'jest.createMockFromModule'
-    });
-
+    var _context$settings, _context$settings$jes;
+
+    const jestVersion = ((_context$settings = context.settings) === null || _context$settings === void 0 ? void 0 : (_context$settings$jes = _context$settings.jest) === null || _context$settings$jes === void 0 ? void 0 : _context$settings$jes.version) || detectJestVersion();
+    const deprecations = { ...(jestVersion >= 15 && {
+        'jest.resetModuleRegistry': 'jest.resetModules'
+      }),
+      ...(jestVersion >= 17 && {
+        'jest.addMatchers': 'expect.extend'
+      }),
+      ...(jestVersion >= 21 && {
+        'require.requireMock': 'jest.requireMock',
+        'require.requireActual': 'jest.requireActual'
+      }),
+      ...(jestVersion >= 22 && {
+        'jest.runTimersToTime': 'jest.advanceTimersByTime'
+      }),
+      ...(jestVersion >= 26 && {
+        'jest.genMockFromModule': 'jest.createMockFromModule'
+      })
+    };
     return {
       CallExpression(node) {
         if (node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
@@ -104,7 +101,6 @@ var _default = (0, _utils.createRule)({
           node,
 
           fix(fixer) {
-            // eslint-disable-next-line prefer-const
             let [name, func] = replacement.split('.');
 
             if (callee.property.type === _experimentalUtils.AST_NODE_TYPES.Literal) {

package/lib/rules/{no-test-callback.js → no-done-callback.js}

@@ -9,17 +9,29 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
+const findCallbackArg = node => {
+  if ((0, _utils.isHook)(node) && node.arguments.length >= 1) {
+    return node.arguments[0];
+  }
+
+  if ((0, _utils.isTestCase)(node) && node.arguments.length >= 2) {
+    return node.arguments[1];
+  }
+
+  return null;
+};
+
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
       category: 'Best Practices',
-      description: 'Avoid using a callback in asynchronous tests',
+      description: 'Avoid using a callback in asynchronous tests and hooks',
       recommended: 'error',
       suggestion: true
     },
     messages: {
-      illegalTestCallback: 'Illegal usage of test callback',
+      noDoneCallback: 'Return a Promise instead of relying on callback parameter',
       suggestWrappingInPromise: 'Wrap in `new Promise({{ callback }} => ...`',
       useAwaitInsteadOfCallback: 'Use await instead of callback in async functions'
     },
@@ -31,13 +43,9 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isTestCase)(node) || node.arguments.length !== 2) {
-          return;
-        }
-
-        const [, callback] = node.arguments;
+        const callback = findCallbackArg(node);
 
-        if (!(0, _utils.isFunction)(callback) || callback.params.length !== 1) {
+        if (!callback || !(0, _utils.isFunction)(callback) || callback.params.length !== 1) {
           return;
         }
 
@@ -46,7 +54,7 @@ var _default = (0, _utils.createRule)({
         if (argument.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
           context.report({
             node: argument,
-            messageId: 'illegalTestCallback'
+            messageId: 'noDoneCallback'
           });
           return;
         }
@@ -61,7 +69,7 @@ var _default = (0, _utils.createRule)({
 
         context.report({
           node: argument,
-          messageId: 'illegalTestCallback',
+          messageId: 'noDoneCallback',
           suggest: [{
             messageId: 'suggestWrappingInPromise',
             data: {
@@ -72,12 +80,6 @@ var _default = (0, _utils.createRule)({
               const {
                 body
               } = callback;
-              /* istanbul ignore if https://github.com/typescript-eslint/typescript-eslint/issues/734 */
-
-              if (!body) {
-                throw new Error(`Unexpected null when attempting to fix ${context.getFilename()} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
-              }
-
               const sourceCode = context.getSourceCode();
               const firstBodyToken = sourceCode.getFirstToken(body);
               const lastBodyToken = sourceCode.getLastToken(body);

package/lib/rules/no-focused-tests.js

@@ -14,7 +14,7 @@ const testFunctions = new Set([_utils.DescribeAlias.describe, ...validTestCaseNa
 
 const isConcurrentExpression = expression => (0, _utils.isSupportedAccessor)(expression.property, _utils.TestCaseProperty.concurrent) && !!expression.parent && expression.parent.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression;
 
-const matchesTestFunction = object => 'name' in object && (object.name in _utils.TestCaseName || object.name in _utils.DescribeAlias);
+const matchesTestFunction = object => 'name' in object && typeof object.name === 'string' && (object.name in _utils.TestCaseName || object.name in _utils.DescribeAlias);
 
 const isCallToFocusedTestFunction = object => object.name.startsWith('f') && testFunctions.has(object.name.substring(1));
 

package/lib/rules/no-if.js

@@ -11,7 +11,7 @@ var _utils = require("./utils");
 
 const testCaseNames = new Set([...Object.keys(_utils.TestCaseName), 'it.only', 'it.concurrent.only', 'it.skip', 'it.concurrent.skip', 'test.only', 'test.concurrent.only', 'test.skip', 'test.concurrent.skip', 'fit.concurrent']);
 
-const isTestArrowFunction = node => node.parent !== undefined && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && testCaseNames.has((0, _utils.getNodeName)(node.parent.callee));
+const isTestFunctionExpression = node => node.parent !== undefined && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && testCaseNames.has((0, _utils.getNodeName)(node.parent.callee));
 
 const conditionName = {
   [_experimentalUtils.AST_NODE_TYPES.ConditionalExpression]: 'conditional',
@@ -61,8 +61,8 @@ var _default = (0, _utils.createRule)({
         }
       },
 
-      FunctionExpression() {
-        stack.push(false);
+      FunctionExpression(node) {
+        stack.push(isTestFunctionExpression(node));
       },
 
       FunctionDeclaration(node) {
@@ -72,7 +72,7 @@ var _default = (0, _utils.createRule)({
       },
 
       ArrowFunctionExpression(node) {
-        stack.push(isTestArrowFunction(node));
+        stack.push(isTestFunctionExpression(node));
       },
 
       IfStatement: validate,

package/lib/rules/no-interpolation-in-snapshots.js

@@ -15,7 +15,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow string interpolation inside snapshots',
-      recommended: false
+      recommended: 'error'
     },
     messages: {
       noInterpolation: 'Do not use string interpolation inside of snapshots'

package/lib/rules/no-jasmine-globals.js

@@ -15,7 +15,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow Jasmine globals',
-      recommended: 'warn'
+      recommended: 'error'
     },
     messages: {
       illegalGlobal: 'Illegal usage of global `{{ global }}`, prefer `{{ replacement }}`',

package/lib/rules/no-large-snapshots.js

@@ -11,16 +11,9 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 const reportOnViolation = (context, node, {
   maxSize: lineLimit = 50,
-  whitelistedSnapshots = {},
-  allowedSnapshots = whitelistedSnapshots
+  allowedSnapshots = {}
 }) => {
   const startLine = node.loc.start.line;
   const endLine = node.loc.end.line;
@@ -88,14 +81,6 @@ var _default = (0, _utils.createRule)({
           additionalProperties: {
             type: 'array'
           }
-        },
-        whitelistedSnapshots: {
-          type: 'object',
-          patternProperties: {
-            '.*': {
-              type: 'array'
-            }
-          }
         }
       },
       additionalProperties: false
@@ -104,10 +89,6 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [{}],
 
   create(context, [options]) {
-    if ('whitelistedSnapshots' in options) {
-      console.warn('jest/no-large-snapshots: the "whitelistedSnapshots" option has been renamed to "allowedSnapshots"');
-    }
-
     if (context.getFilename().endsWith('.snap')) {
       return {
         ExpressionStatement(node) {
@@ -115,22 +96,34 @@ var _default = (0, _utils.createRule)({
         }
 
       };
-    } else if (context.getFilename().endsWith('.js')) {
-      return {
-        CallExpression(node) {
-          if ('property' in node.callee && ((0, _utils.isSupportedAccessor)(node.callee.property, 'toMatchInlineSnapshot') || (0, _utils.isSupportedAccessor)(node.callee.property, 'toThrowErrorMatchingInlineSnapshot'))) {
-            var _options$inlineMaxSiz;
+    }
 
-            reportOnViolation(context, node, _objectSpread(_objectSpread({}, options), {}, {
-              maxSize: (_options$inlineMaxSiz = options.inlineMaxSize) !== null && _options$inlineMaxSiz !== void 0 ? _options$inlineMaxSiz : options.maxSize
-            }));
-          }
+    return {
+      CallExpression(node) {
+        var _matcher$node$parent;
+
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
         }
 
-      };
-    }
+        const {
+          matcher
+        } = (0, _utils.parseExpectCall)(node);
+
+        if ((matcher === null || matcher === void 0 ? void 0 : (_matcher$node$parent = matcher.node.parent) === null || _matcher$node$parent === void 0 ? void 0 : _matcher$node$parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes(matcher.name)) {
+          var _options$inlineMaxSiz;
+
+          reportOnViolation(context, matcher.node.parent, { ...options,
+            maxSize: (_options$inlineMaxSiz = options.inlineMaxSize) !== null && _options$inlineMaxSiz !== void 0 ? _options$inlineMaxSiz : options.maxSize
+          });
+        }
+      }
 
-    return {};
+    };
   }
 
 });

package/lib/rules/no-test-return-statement.js

@@ -12,7 +12,7 @@ var _utils = require("./utils");
 const getBody = args => {
   const [, secondArg] = args;
 
-  if (secondArg && (0, _utils.isFunction)(secondArg) && secondArg.body && secondArg.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+  if (secondArg && (0, _utils.isFunction)(secondArg) && secondArg.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
     return secondArg.body.body;
   }
 

package/lib/rules/prefer-expect-assertions.js

@@ -39,13 +39,27 @@ var _default = (0, _utils.createRule)({
       suggestRemovingExtraArguments: 'Remove extra arguments'
     },
     type: 'suggestion',
-    schema: []
+    schema: [{
+      type: 'object',
+      properties: {
+        onlyFunctionsWithAsyncKeyword: {
+          type: 'boolean'
+        }
+      },
+      additionalProperties: false
+    }]
   },
-  defaultOptions: [],
+  defaultOptions: [{
+    onlyFunctionsWithAsyncKeyword: false
+  }],
 
-  create(context) {
+  create(context, [options]) {
     return {
       'CallExpression[callee.name=/^(it|test)$/][arguments.1.body.body]'(node) {
+        if (options.onlyFunctionsWithAsyncKeyword && !node.arguments[1].async) {
+          return;
+        }
+
         const testFuncBody = node.arguments[1].body.body;
 
         if (!isFirstLineExprStmt(testFuncBody)) {

package/lib/rules/prefer-to-have-length.js

@@ -40,7 +40,7 @@ var _default = (0, _utils.createRule)({
           matcher
         } = (0, _utils.parseExpectCall)(node);
 
-        if (!matcher || !(0, _utils.isParsedEqualityMatcherCall)(matcher) || !argument || argument.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || !(0, _utils.isSupportedAccessor)(argument.property, 'length') || argument.property.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
+        if (!matcher || !(0, _utils.isParsedEqualityMatcherCall)(matcher) || (argument === null || argument === void 0 ? void 0 : argument.type) !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || !(0, _utils.isSupportedAccessor)(argument.property, 'length') || argument.property.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
           return;
         }
 

package/lib/rules/prefer-todo.js

@@ -13,14 +13,8 @@ function isEmptyFunction(node) {
   if (!(0, _utils.isFunction)(node)) {
     return false;
   }
-  /* istanbul ignore if https://github.com/typescript-eslint/typescript-eslint/issues/734 */
 
-
-  if (!node.body) {
-    throw new Error(`Unexpected null while performing prefer-todo - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
-  }
-
-  return node.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement && node.body.body && !node.body.body.length;
+  return node.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement && !node.body.body.length;
 }
 
 function createTodoFixer(node, fixer) {

package/lib/rules/require-to-throw-message.js

@@ -26,6 +26,8 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
+        var _matcher$arguments;
+
         if (!(0, _utils.isExpectCall)(node)) {
           return;
         }
@@ -35,7 +37,7 @@ var _default = (0, _utils.createRule)({
           modifier
         } = (0, _utils.parseExpectCall)(node);
 
-        if (matcher && matcher.arguments && matcher.arguments.length === 0 && ['toThrow', 'toThrowError'].includes(matcher.name) && (!modifier || !(modifier.name === _utils.ModifierName.not || modifier.negation))) {
+        if ((matcher === null || matcher === void 0 ? void 0 : (_matcher$arguments = matcher.arguments) === null || _matcher$arguments === void 0 ? void 0 : _matcher$arguments.length) === 0 && ['toThrow', 'toThrowError'].includes(matcher.name) && (!modifier || !(modifier.name === _utils.ModifierName.not || modifier.negation))) {
           // Look for `toThrow` calls with no arguments.
           context.report({
             messageId: 'addErrorMessage',

package/lib/rules/utils.js

@@ -12,12 +12,6 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _package = require("../../package.json");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 const REPO_URL = 'https://github.com/jest-community/eslint-plugin-jest';
 
 const createRule = _experimentalUtils.ESLintUtils.RuleCreator(name => {
@@ -231,7 +225,8 @@ const parseExpectMember = expectMember => ({
   node: expectMember
 });
 
-const reparseAsMatcher = parsedMember => _objectSpread(_objectSpread({}, parsedMember), {}, {
+const reparseAsMatcher = parsedMember => ({ ...parsedMember,
+
   /**
    * The arguments being passed to this `Matcher`, if any.
    *
@@ -265,9 +260,9 @@ const reparseMemberAsModifier = parsedMember => {
   }
 
   const negation = parsedMember.node.parent && isExpectMember(parsedMember.node.parent, ModifierName.not) ? parsedMember.node.parent : undefined;
-  return _objectSpread(_objectSpread({}, parsedMember), {}, {
+  return { ...parsedMember,
     negation
-  });
+  };
 };
 
 const isSpecificMember = (member, specific) => member.name === specific;

package/lib/rules/valid-describe.js

@@ -86,7 +86,7 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        if (callback.body && callback.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+        if (callback.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
           callback.body.body.forEach(node => {
             if (node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
               context.report({

package/lib/rules/valid-expect-in-promise.js

@@ -76,8 +76,8 @@ const isParentThenOrPromiseReturned = (node, testFunctionBody) => node.type ===
 
 const verifyExpectWithReturn = (promiseCallbacks, node, context, testFunctionBody) => {
   promiseCallbacks.some(promiseCallback => {
-    if (promiseCallback && (0, _utils.isFunction)(promiseCallback) && promiseCallback.body) {
-      if (isExpectCallPresentInFunction(promiseCallback.body) && node.parent && node.parent.parent && !isParentThenOrPromiseReturned(node.parent.parent, testFunctionBody)) {
+    if (promiseCallback && (0, _utils.isFunction)(promiseCallback)) {
+      if (isExpectCallPresentInFunction(promiseCallback.body) && node.parent.parent && !isParentThenOrPromiseReturned(node.parent.parent, testFunctionBody)) {
         reportReturnRequired(context, node.parent.parent);
         return true;
       }
@@ -118,11 +118,6 @@ var _default = (0, _utils.createRule)({
           const {
             body
           } = testFunction;
-          /* istanbul ignore if https://github.com/typescript-eslint/typescript-eslint/issues/734 */
-
-          if (!body) {
-            throw new Error(`Unexpected null when attempting to fix ${context.getFilename()} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
-          }
 
           if (body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
             return;

package/lib/rules/valid-expect.js

@@ -190,7 +190,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if (matcher.node.parent && (0, _utils.isExpectMember)(matcher.node.parent)) {
+        if ((0, _utils.isExpectMember)(matcher.node.parent)) {
           context.report({
             messageId: 'modifierUnknown',
             data: {
@@ -210,7 +210,7 @@ var _default = (0, _utils.createRule)({
 
         const parentNode = matcher.node.parent;
 
-        if (!modifier || !parentNode || !parentNode.parent || modifier.name === _utils.ModifierName.not) {
+        if (!parentNode.parent || !modifier || modifier.name === _utils.ModifierName.not) {
           return;
         }
         /**

package/lib/rules/valid-title.js

@@ -48,7 +48,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Enforce valid titles',
-      recommended: false
+      recommended: 'error'
     },
     messages: {
       titleMustBeString: 'Title must be a string',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "23.20.0",
+  "version": "24.1.0",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",
@@ -20,11 +20,11 @@
     "lib/"
   ],
   "scripts": {
-    "build": "babel --extensions .js,.ts src --out-dir lib --copy-files",
-    "postbuild": "rimraf lib/__tests__ lib/**/__tests__",
+    "build": "babel --extensions .js,.ts src --out-dir lib --copy-files && rimraf lib/__tests__ 'lib/**/__tests__'",
     "lint": "eslint . --ignore-pattern '!.eslintrc.js' --ext js,ts",
-    "prepack": "yarn build",
-    "prettylint": "prettylint docs/**/*.md README.md package.json",
+    "prepack": "rimraf lib && yarn build",
+    "prettier:check": "prettier --check 'docs/**/*.md' README.md '.github/**' package.json tsconfig.json src/globals.json .yarnrc.yml",
+    "prettier:write": "prettier --write 'docs/**/*.md' README.md '.github/**' package.json tsconfig.json src/globals.json .yarnrc.yml",
     "test": "jest",
     "tools:regenerate-docs": "ts-node -T tools/regenerate-docs",
     "typecheck": "tsc -p ."
@@ -41,14 +41,8 @@
     ]
   },
   "lint-staged": {
-    "*.{js,ts}": [
-      "eslint --fix",
-      "git add"
-    ],
-    "*.{md,json}": [
-      "prettier --write",
-      "git add"
-    ]
+    "*.{js,ts}": "eslint --fix",
+    "*.{md,json,yml}": "prettier --write"
   },
   "prettier": {
     "arrowParens": "avoid",
@@ -87,28 +81,28 @@
     ]
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "^2.5.0"
+    "@typescript-eslint/experimental-utils": "^4.0.1"
   },
   "devDependencies": {
     "@babel/cli": "^7.4.4",
     "@babel/core": "^7.4.4",
     "@babel/preset-env": "^7.4.4",
     "@babel/preset-typescript": "^7.3.3",
-    "@commitlint/cli": "^8.2.0",
-    "@commitlint/config-conventional": "^8.2.0",
+    "@commitlint/cli": "^11.0.0",
+    "@commitlint/config-conventional": "^11.0.0",
     "@schemastore/package": "^0.0.6",
-    "@semantic-release/changelog": "^3.0.5",
-    "@semantic-release/git": "^7.0.17",
+    "@semantic-release/changelog": "^5.0.1",
+    "@semantic-release/git": "^9.0.0",
     "@types/dedent": "^0.7.0",
-    "@types/jest": "^25.1.0",
-    "@types/node": "^12.6.6",
-    "@types/prettier": "^1.19.0",
-    "@typescript-eslint/eslint-plugin": "^2.5.0",
-    "@typescript-eslint/parser": "^2.5.0",
-    "babel-jest": "^25.2.0",
+    "@types/jest": "^26.0.0",
+    "@types/node": "^14.0.0",
+    "@types/prettier": "^2.0.0",
+    "@typescript-eslint/eslint-plugin": "^4.0.1",
+    "@typescript-eslint/parser": "^4.0.1",
+    "babel-jest": "^26.0.1",
     "babel-plugin-replace-ts-export-assignment": "^0.0.2",
     "dedent": "^0.7.0",
-    "eslint": "^5.1.0 || ^6.0.0",
+    "eslint": "^5.1.0 || ^6.0.0 || ^7.0.0",
     "eslint-config-prettier": "^6.5.0",
     "eslint-plugin-eslint-comments": "^3.1.2",
     "eslint-plugin-eslint-config": "^1.0.2",
@@ -116,23 +110,22 @@
     "eslint-plugin-import": "^2.20.2",
     "eslint-plugin-node": "^11.0.0",
     "eslint-plugin-prettier": "^3.0.0",
-    "husky": "^3.0.9",
-    "jest": "^25.2.0",
+    "husky": "^4.2.5",
+    "jest": "^26.0.1",
     "jest-runner-eslint": "^0.10.0",
-    "lint-staged": "^9.4.2",
-    "prettier": "^1.19.1",
-    "prettylint": "^1.0.0",
+    "lint-staged": "^10.2.2",
+    "prettier": "^2.0.5",
     "resolve-from": "^5.0.0",
     "rimraf": "^3.0.0",
-    "semantic-release": "^15.13.28",
-    "ts-node": "^8.10.1",
-    "typescript": "^3.5.3"
+    "semantic-release": "^17.0.7",
+    "ts-node": "^9.0.0",
+    "typescript": "^4.0.0"
   },
   "peerDependencies": {
     "eslint": ">=5"
   },
   "engines": {
-    "node": ">=8"
+    "node": ">=10"
   },
   "release": {
     "plugins": [

package/docs/rules/no-test-callback.md

@@ -1,76 +0,0 @@
-# Avoid using a callback in asynchronous tests (`no-test-callback`)
-
-Jest allows you to pass a callback to test definitions, typically called `done`,
-that is later invoked to indicate that the asynchronous test is complete.
-
-However, that means that if your test throws (e.g. because of a failing
-assertion), `done` will never be called unless you manually use `try-catch`.
-
-```js
-test('some test', done => {
-  expect(false).toBe(true);
-  done();
-});
-```
-
-The test above will time out instead of failing the assertions, since `done` is
-never called.
-
-Correct way of doing the same thing is to wrap it in `try-catch`.
-
-```js
-test('some test', done => {
-  try {
-    expect(false).toBe(true);
-    done();
-  } catch (e) {
-    done(e);
-  }
-});
-```
-
-However, Jest supports a second way of having asynchronous tests - using
-promises.
-
-```js
-test('some test', () => {
-  return new Promise(done => {
-    expect(false).toBe(true);
-    done();
-  });
-});
-```
-
-Even though `done` is never called here, the Promise will still reject, and Jest
-will report the assertion error correctly.
-
-## Rule details
-
-This rule triggers a warning if you have a `done` callback in your test.
-
-The following patterns are considered warnings:
-
-```js
-test('myFunction()', done => {
-  // ...
-});
-
-test('myFunction()', function(done) {
-  // ...
-});
-```
-
-The following patterns are not considered warnings:
-
-```js
-test('myFunction()', () => {
-  expect(myFunction()).toBeTruthy();
-});
-
-test('myFunction()', () => {
-  return new Promise(done => {
-    expect(myFunction()).toBeTruthy();
-    done();
-  });
-});
-```