eslint-plugin-jest 23.15.0 → 23.18.0

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+# [23.18.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.17.1...v23.18.0) (2020-07-05)
+
+
+### Features
+
+* **valid-title:** support `mustMatch` & `mustNotMatch` options ([#608](https://github.com/jest-community/eslint-plugin-jest/issues/608)) ([4c7207e](https://github.com/jest-community/eslint-plugin-jest/commit/4c7207ebbb274f7b584225ad65ffb96a4328240e)), closes [#233](https://github.com/jest-community/eslint-plugin-jest/issues/233)
+
+## [23.17.1](https://github.com/jest-community/eslint-plugin-jest/compare/v23.17.0...v23.17.1) (2020-06-23)
+
+
+### Bug Fixes
+
+* **lowercase-name:** ignore all top level describes when option is true ([#614](https://github.com/jest-community/eslint-plugin-jest/issues/614)) ([624018a](https://github.com/jest-community/eslint-plugin-jest/commit/624018aa181e7c0ce87457a4f9c212c7891987a8)), closes [#613](https://github.com/jest-community/eslint-plugin-jest/issues/613)
+
+# [23.17.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.16.0...v23.17.0) (2020-06-23)
+
+
+### Features
+
+* **lowercase-name:** support `ignoreTopLevelDescribe` option ([#611](https://github.com/jest-community/eslint-plugin-jest/issues/611)) ([36fdcc5](https://github.com/jest-community/eslint-plugin-jest/commit/36fdcc553ca40bc2ca2e9ca7e04f8e9e4a315274)), closes [#247](https://github.com/jest-community/eslint-plugin-jest/issues/247)
+
+# [23.16.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.15.0...v23.16.0) (2020-06-21)
+
+
+### Features
+
+* create `no-conditional-expect` rule ([aba53e4](https://github.com/jest-community/eslint-plugin-jest/commit/aba53e4061f3b636ab0c0270e183c355c6f301e0))
+* deprecate `no-try-expect` in favor of `no-conditional-expect` ([6d07cad](https://github.com/jest-community/eslint-plugin-jest/commit/6d07cadd5f78ed7a64a86792931d49d3cd943d69))
+
 # [23.15.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.14.0...v23.15.0) (2020-06-21)
 
 

package/README.md

@@ -134,6 +134,7 @@ 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-disabled-tests](docs/rules/no-disabled-tests.md)                   | Disallow disabled tests                                         | ![recommended][] |              |
 | [no-duplicate-hooks](docs/rules/no-duplicate-hooks.md)                 | Disallow duplicate setup and teardown hooks                     |                  |              |
@@ -151,7 +152,6 @@ installations requiring long-term consistency.
 | [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                        |                  |              |
-| [no-try-expect](docs/rules/no-try-expect.md)                           | Prefer using toThrow for exception tests                        | ![recommended][] |              |
 | [prefer-called-with](docs/rules/prefer-called-with.md)                 | Suggest using `toBeCalledWith()` OR `toHaveBeenCalledWith()`    |                  |              |
 | [prefer-expect-assertions](docs/rules/prefer-expect-assertions.md)     | Suggest using `expect.assertions()` OR `expect.hasAssertions()` |                  | ![suggest][] |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)               | Suggest to have all hooks at top level                          |                  |              |

package/docs/rules/lowercase-name.md

@@ -86,3 +86,21 @@ Example of **correct** code for the `{ "allowedPrefixes": ["GET"] }` option:
 
 describe('GET /live');
 ```
+
+### `ignoreTopLevelDescribe`
+
+This option can be set to allow only the top-level `describe` blocks to have a
+title starting with an upper-case letter.
+
+Example of **correct** code for the `{ "ignoreTopLevelDescribe": true }` option:
+
+```js
+/* eslint jest/lowercase-name: ["error", { "ignoreTopLevelDescribe": true }] */
+describe('MyClass', () => {
+  describe('#myMethod', () => {
+    it('does things', () => {
+      //
+    });
+  });
+});
+```

package/docs/rules/no-conditional-expect.md

@@ -0,0 +1,70 @@
+# Prevent calling `expect` conditionally (`no-conditional-expect`)
+
+This rule prevents the use of `expect` in conditional blocks, such as `if`s &
+`catch`s.
+
+## Rule Details
+
+Jest considered a test to have failed if it throws an error, rather than on if
+any particular function is called, meaning conditional calls to `expect` could
+result in tests silently being skipped.
+
+Additionally, conditionals tend to make tests more brittle and complex, as they
+increase the amount of mental thinking needed to understand what is actually
+being tested.
+
+While `expect.assertions` & `expect.hasAssertions` can help prevent tests from
+silently being skipped, when combined with conditionals they typically result in
+even more complexity being introduced.
+
+The following patterns are warnings:
+
+```js
+it('foo', () => {
+  doTest && expect(1).toBe(2);
+});
+
+it('bar', () => {
+  if (!skipTest) {
+    expect(1).toEqual(2);
+  }
+});
+
+it('baz', async () => {
+  try {
+    await foo();
+  } catch (err) {
+    expect(err).toMatchObject({ code: 'MODULE_NOT_FOUND' });
+  }
+});
+```
+
+The following patterns are not warnings:
+
+```js
+it('foo', () => {
+  expect(!value).toBe(false);
+});
+
+function getValue() {
+  if (process.env.FAIL) {
+    return 1;
+  }
+
+  return 2;
+}
+
+it('foo', () => {
+  expect(getValue()).toBe(2);
+});
+
+it('validates the request', () => {
+  try {
+    processRequest(request);
+  } catch {
+    // ignore errors
+  } finally {
+    expect(validRequest).toHaveBeenCalledWith(request);
+  }
+});
+```

package/docs/rules/no-try-expect.md

@@ -1,5 +1,12 @@
 # Prevent catch assertions in tests (`no-try-expect`)
 
+## Deprecated
+
+This rule has been deprecated in favor of
+[`no-conditional-expect`](no-conditional-expect.md).
+
+---
+
 This rule prevents the use of `expect` inside `catch` blocks.
 
 ## Rule Details

package/docs/rules/valid-title.md

@@ -152,9 +152,11 @@ describe('foo', () => {
 ## Options
 
 ```ts
-interface {
+interface Options {
   ignoreTypeOfDescribeName?: boolean;
   disallowedWords?: string[];
+  mustNotMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
+  mustMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
 }
 ```
 
@@ -172,7 +174,7 @@ Default: `[]`
 A string array of words that are not allowed to be used in test titles. Matching
 is not case-sensitive, and looks for complete words:
 
-Examples of **incorrect** code using `disallowedWords`:
+Examples of **incorrect** code when using `disallowedWords`:
 
 ```js
 // with disallowedWords: ['correct', 'all', 'every', 'properly']
@@ -190,3 +192,37 @@ it('correctly sets the value', () => {});
 test('that everything is as it should be', () => {});
 describe('the proper way to handle things', () => {});
 ```
+
+#### `mustMatch` & `mustNotMatch`
+
+Defaults: `{}`
+
+Allows enforcing that titles must match or must not match a given Regular
+Expression. An object can be provided to apply different Regular Expressions to
+specific Jest test function groups (`describe`, `test`, and `it`).
+
+Examples of **incorrect** code when using `mustMatch`:
+
+```js
+// with mustMatch: '$that'
+describe('the correct way to do things', () => {});
+fit('this there!', () => {});
+
+// with mustMatch: { test: '$that' }
+describe('the tests that will be run', () => {});
+test('the stuff works', () => {});
+xtest('errors that are thrown have messages', () => {});
+```
+
+Examples of **correct** code when using `mustMatch`:
+
+```js
+// with mustMatch: '$that'
+describe('that thing that needs to be done', () => {});
+fit('that this there!', () => {});
+
+// with mustMatch: { test: '$that' }
+describe('the tests that will be run', () => {});
+test('that the stuff works', () => {});
+xtest('that errors that thrown have messages', () => {});
+```

package/lib/index.js

@@ -32,45 +32,28 @@ 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) => Object.assign(acc, {
+const rules = (0, _fs.readdirSync)(rulesDir).map(rule => (0, _path.parse)(rule).name).filter(rule => !excludedFiles.includes(rule)).reduce((acc, curr) => _objectSpread(_objectSpread({}, 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), {}, {
+  [`jest/${name}`]: rule.meta.docs.recommended
+}), {});
 const allRules = Object.keys(rules).reduce((rules, key) => _objectSpread(_objectSpread({}, rules), {}, {
   [`jest/${key}`]: 'error'
 }), {});
+
+const createConfig = rules => ({
+  plugins: ['jest'],
+  env: {
+    'jest/globals': true
+  },
+  rules
+});
+
 module.exports = {
   configs: {
-    all: {
-      plugins: ['jest'],
-      env: {
-        'jest/globals': true
-      },
-      rules: allRules
-    },
-    recommended: {
-      plugins: ['jest'],
-      env: {
-        'jest/globals': true
-      },
-      rules: {
-        'jest/expect-expect': 'warn',
-        'jest/no-commented-out-tests': 'warn',
-        'jest/no-disabled-tests': 'warn',
-        'jest/no-export': 'error',
-        'jest/no-focused-tests': 'error',
-        'jest/no-identical-title': 'error',
-        'jest/no-jest-import': 'error',
-        'jest/no-mocks-import': 'error',
-        'jest/no-jasmine-globals': 'warn',
-        'jest/no-standalone-expect': 'error',
-        'jest/no-test-callback': 'error',
-        'jest/no-test-prefixes': 'error',
-        'jest/no-try-expect': 'error',
-        'jest/valid-describe': 'error',
-        'jest/valid-expect': 'error',
-        'jest/valid-expect-in-promise': 'error'
-      }
-    },
+    all: createConfig(allRules),
+    recommended: createConfig(recommendedRules),
     style: {
       plugins: ['jest'],
       rules: {

package/lib/rules/expect-expect.js

@@ -34,7 +34,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Enforce assertion to be made in a test body',
-      recommended: false
+      recommended: 'warn'
     },
     messages: {
       noAssertions: 'Test has no assertions'

package/lib/rules/lowercase-name.js

@@ -58,6 +58,10 @@ var _default = (0, _utils.createRule)({
             type: 'string'
           },
           additionalItems: false
+        },
+        ignoreTopLevelDescribe: {
+          type: 'boolean',
+          default: false
         }
       },
       additionalProperties: false
@@ -65,19 +69,30 @@ var _default = (0, _utils.createRule)({
   },
   defaultOptions: [{
     ignore: [],
-    allowedPrefixes: []
+    allowedPrefixes: [],
+    ignoreTopLevelDescribe: false
   }],
 
   create(context, [{
     ignore = [],
-    allowedPrefixes = []
+    allowedPrefixes = [],
+    ignoreTopLevelDescribe
   }]) {
+    let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
         if (!isJestFunctionWithLiteralArg(node)) {
           return;
         }
 
+        if ((0, _utils.isDescribe)(node)) {
+          numberOfDescribeBlocks++;
+
+          if (ignoreTopLevelDescribe && numberOfDescribeBlocks === 1) {
+            return;
+          }
+        }
+
         const erroneousMethod = jestFunctionName(node, allowedPrefixes);
 
         if (erroneousMethod && !ignore.includes(node.callee.name)) {
@@ -98,6 +113,12 @@ var _default = (0, _utils.createRule)({
 
           });
         }
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isDescribe)(node)) {
+          numberOfDescribeBlocks--;
+        }
       }
 
     };

package/lib/rules/no-alias-methods.js

@@ -13,7 +13,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow alias methods',
-      recommended: 'warn'
+      recommended: false
     },
     messages: {
       replaceAlias: `Replace {{ alias }}() with its canonical name of {{ canonical }}()`

package/lib/rules/no-commented-out-tests.js

@@ -17,7 +17,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow commented out tests',
-      recommended: false
+      recommended: 'warn'
     },
     messages: {
       commentedTests: 'Some tests seem to be commented'

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

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prevent calling `expect` conditionally',
+      category: 'Best Practices',
+      recommended: false
+    },
+    messages: {
+      conditionalExpect: 'Avoid calling `expect` conditionally`'
+    },
+    type: 'problem',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    let conditionalDepth = 0;
+    let inTestCase = false;
+
+    const increaseConditionalDepth = () => inTestCase && conditionalDepth++;
+
+    const decreaseConditionalDepth = () => inTestCase && conditionalDepth--;
+
+    return {
+      FunctionDeclaration(node) {
+        const declaredVariables = context.getDeclaredVariables(node);
+        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+
+        if (testCallExpressions.length > 0) {
+          inTestCase = true;
+        }
+      },
+
+      CallExpression(node) {
+        if ((0, _utils.isTestCase)(node)) {
+          inTestCase = true;
+        }
+
+        if (inTestCase && (0, _utils.isExpectCall)(node) && conditionalDepth > 0) {
+          context.report({
+            messageId: 'conditionalExpect',
+            node
+          });
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTestCase)(node)) {
+          inTestCase = false;
+        }
+      },
+
+      CatchClause: increaseConditionalDepth,
+      'CatchClause:exit': decreaseConditionalDepth,
+      IfStatement: increaseConditionalDepth,
+      'IfStatement:exit': decreaseConditionalDepth,
+      SwitchStatement: increaseConditionalDepth,
+      'SwitchStatement:exit': decreaseConditionalDepth,
+      ConditionalExpression: increaseConditionalDepth,
+      'ConditionalExpression:exit': decreaseConditionalDepth,
+      LogicalExpression: increaseConditionalDepth,
+      'LogicalExpression:exit': decreaseConditionalDepth
+    };
+  }
+
+});
+
+exports.default = _default;

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

@@ -13,7 +13,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow disabled tests',
-      recommended: false
+      recommended: 'warn'
     },
     messages: {
       missingFunction: 'Test is missing function argument',

package/lib/rules/no-export.js

@@ -15,7 +15,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Prevent exporting from test files',
-      recommended: false
+      recommended: 'error'
     },
     messages: {
       unexpectedExport: `Do not export from a test file.`

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

@@ -26,7 +26,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow focused tests',
-      recommended: false
+      recommended: 'error'
     },
     messages: {
       focusedTest: 'Unexpected focused test.'

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: 'error'
+      recommended: 'warn'
     },
     messages: {
       illegalGlobal: 'Illegal usage of global `{{ global }}`, prefer `{{ replacement }}`',

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

@@ -46,7 +46,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Prevents expects that are outside of an it or test block.',
-      recommended: false
+      recommended: 'error'
     },
     messages: {
       unexpectedExpect: 'Expect must be inside of a test block.'

package/lib/rules/no-test-callback.js

@@ -15,7 +15,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Avoid using a callback in asynchronous tests',
-      recommended: false,
+      recommended: 'error',
       suggestion: true
     },
     messages: {

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

@@ -13,8 +13,10 @@ var _default = (0, _utils.createRule)({
     docs: {
       description: 'Prefer using toThrow for exception tests',
       category: 'Best Practices',
-      recommended: false
+      recommended: 'error'
     },
+    deprecated: true,
+    replacedBy: ['no-conditional-expect'],
     messages: {
       noTryExpect: ['Tests should use Jest‘s exception helpers.', 'Use "expect(() => yourFunction()).toThrow()" for synchronous tests,', 'or "await expect(yourFunction()).rejects.toThrow()" for async tests'].join(' ')
     },

package/lib/rules/valid-describe.js

@@ -25,7 +25,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Possible Errors',
       description: 'Enforce valid `describe()` callback',
-      recommended: 'warn'
+      recommended: 'error'
     },
     messages: {
       nameAndCallback: 'Describe requires name and callback arguments',

package/lib/rules/valid-title.js

@@ -25,6 +25,23 @@ const doesBinaryExpressionContainStringNode = binaryExp => {
 
 const quoteStringValue = node => node.type === _experimentalUtils.AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
 
+const compileMatcherPatterns = matchers => {
+  if (typeof matchers === 'string') {
+    const matcher = new RegExp(matchers, 'u');
+    return {
+      describe: matcher,
+      test: matcher,
+      it: matcher
+    };
+  }
+
+  return {
+    describe: matchers.describe ? new RegExp(matchers.describe, 'u') : null,
+    test: matchers.test ? new RegExp(matchers.test, 'u') : null,
+    it: matchers.it ? new RegExp(matchers.it, 'u') : null
+  };
+};
+
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -38,7 +55,9 @@ var _default = (0, _utils.createRule)({
       emptyTitle: '{{ jestFunctionName }} should not have an empty title',
       duplicatePrefix: 'should not have duplicate prefix',
       accidentalSpace: 'should not have leading or trailing spaces',
-      disallowedWord: '"{{ word }}" is not allowed in test titles.'
+      disallowedWord: '"{{ word }}" is not allowed in test titles.',
+      mustNotMatch: '{{ jestFunctionName }} should not match {{ pattern }}',
+      mustMatch: '{{ jestFunctionName }} should match {{ pattern }}'
     },
     type: 'suggestion',
     schema: [{
@@ -53,6 +72,44 @@ var _default = (0, _utils.createRule)({
           items: {
             type: 'string'
           }
+        },
+        mustNotMatch: {
+          oneOf: [{
+            type: 'string'
+          }, {
+            type: 'object',
+            properties: {
+              describe: {
+                type: 'string'
+              },
+              test: {
+                type: 'string'
+              },
+              it: {
+                type: 'string'
+              }
+            },
+            additionalProperties: false
+          }]
+        },
+        mustMatch: {
+          oneOf: [{
+            type: 'string'
+          }, {
+            type: 'object',
+            properties: {
+              describe: {
+                type: 'string'
+              },
+              test: {
+                type: 'string'
+              },
+              it: {
+                type: 'string'
+              }
+            },
+            additionalProperties: false
+          }]
         }
       },
       additionalProperties: false
@@ -66,9 +123,13 @@ var _default = (0, _utils.createRule)({
 
   create(context, [{
     ignoreTypeOfDescribeName,
-    disallowedWords = []
+    disallowedWords = [],
+    mustNotMatch,
+    mustMatch
   }]) {
     const disallowedWordsRegexp = new RegExp(`\\b(${disallowedWords.join('|')})\\b`, 'iu');
+    const mustNotMatchPatterns = compileMatcherPatterns(mustNotMatch !== null && mustNotMatch !== void 0 ? mustNotMatch : {});
+    const mustMatchPatterns = compileMatcherPatterns(mustMatch !== null && mustMatch !== void 0 ? mustMatch : {});
     return {
       CallExpression(node) {
         if (!(0, _utils.isDescribe)(node) && !(0, _utils.isTestCase)(node)) {
@@ -142,6 +203,39 @@ var _default = (0, _utils.createRule)({
             fix: fixer => [fixer.replaceTextRange(argument.range, quoteStringValue(argument).replace(/^([`'"]).+? /u, '$1'))]
           });
         }
+
+        const [jestFunctionName] = nodeName.split('.');
+        const mustNotMatchPattern = mustNotMatchPatterns[jestFunctionName];
+
+        if (mustNotMatchPattern) {
+          if (mustNotMatchPattern.test(title)) {
+            context.report({
+              messageId: 'mustNotMatch',
+              node: argument,
+              data: {
+                jestFunctionName,
+                pattern: mustNotMatchPattern
+              }
+            });
+            return;
+          }
+        }
+
+        const mustMatchPattern = mustMatchPatterns[jestFunctionName];
+
+        if (mustMatchPattern) {
+          if (!mustMatchPattern.test(title)) {
+            context.report({
+              messageId: 'mustMatch',
+              node: argument,
+              data: {
+                jestFunctionName,
+                pattern: mustMatchPattern
+              }
+            });
+            return;
+          }
+        }
       }
 
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "23.15.0",
+  "version": "23.18.0",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",
@@ -23,10 +23,8 @@
     "build": "babel --extensions .js,.ts src --out-dir lib --copy-files",
     "postbuild": "rimraf lib/__tests__ lib/**/__tests__",
     "lint": "eslint . --ignore-pattern '!.eslintrc.js' --ext js,ts",
-    "prepare": "yarn build && yarn postbuild",
-    "prepublishOnly": "yarn build",
+    "prepack": "yarn build",
     "prettylint": "prettylint docs/**/*.md README.md package.json",
-    "pretest": "yarn build",
     "test": "jest",
     "tools:generate-rules-table": "ts-node -T tools/generate-rules-table",
     "typecheck": "tsc -p ."
@@ -102,9 +100,9 @@
     "@semantic-release/changelog": "^3.0.5",
     "@semantic-release/git": "^7.0.17",
     "@types/dedent": "^0.7.0",
-    "@types/eslint": "^6.1.3",
     "@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",
@@ -120,7 +118,7 @@
     "eslint-plugin-prettier": "^3.0.0",
     "husky": "^3.0.9",
     "jest": "^25.2.0",
-    "jest-runner-eslint": "^0.8.0",
+    "jest-runner-eslint": "^0.10.0",
     "lint-staged": "^9.4.2",
     "prettier": "^1.19.1",
     "prettylint": "^1.0.0",