eslint-plugin-jest 26.6.0 → 26.7.0

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <a href="https://eslint.org/">
-    <img width="150" height="150" src="https://eslint.org/assets/img/logo.svg">
+    <img width="150" height="150" src="https://eslint.org/assets/images/logo/eslint-logo-color.svg">
   </a>
   <a href="https://facebook.github.io/jest/">
     <img width="150" height="150" vspace="" hspace="25" src="https://jestjs.io/img/jest.png">
@@ -232,6 +232,7 @@ installations requiring long-term consistency.
 | [prefer-hooks-in-order](docs/rules/prefer-hooks-in-order.md)                 | Prefer having hooks in a consistent order                           |                  |              |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                          |                  |              |
 | [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                        |                  | ![fixable][] |
+| [prefer-mock-promise-shorthand](docs/rules/prefer-mock-promise-shorthand.md) | Prefer mock resolved/rejected shorthands for promises               |                  | ![fixable][] |
 | [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                     |                  |              |
 | [prefer-spy-on](docs/rules/prefer-spy-on.md)                                 | Suggest using `jest.spyOn()`                                        |                  | ![fixable][] |
 | [prefer-strict-equal](docs/rules/prefer-strict-equal.md)                     | Suggest using `toStrictEqual()`                                     |                  | ![suggest][] |

package/docs/rules/prefer-mock-promise-shorthand.md

@@ -0,0 +1,34 @@
+# Prefer mock resolved/rejected shorthands for promises (`prefer-mock-promise-shorthand`)
+
+When working with mocks of functions that return promises, Jest provides some
+API sugar functions to reduce the amount of boilerplate you have to write.
+
+These methods should be preferred when possible.
+
+## Rule Details
+
+The following patterns are warnings:
+
+```js
+jest.fn().mockImplementation(() => Promise.resolve(123));
+jest
+  .spyOn(fs.promises, 'readFile')
+  .mockReturnValue(Promise.reject(new Error('oh noes!')));
+
+myFunction
+  .mockReturnValueOnce(Promise.resolve(42))
+  .mockImplementationOnce(() => Promise.resolve(42))
+  .mockReturnValue(Promise.reject(new Error('too many calls!')));
+```
+
+The following patterns are not warnings:
+
+```js
+jest.fn().mockResolvedValue(123);
+jest.spyOn(fs.promises, 'readFile').mockRejectedValue(new Error('oh noes!'));
+
+myFunction
+  .mockResolvedValueOnce(42)
+  .mockResolvedValueOnce(42)
+  .mockRejectedValue(new Error('too many calls!'));
+```

package/lib/rules/prefer-called-with.js

@@ -16,7 +16,7 @@ var _default = (0, _utils.createRule)({
       recommended: false
     },
     messages: {
-      preferCalledWith: 'Prefer {{name}}With(/* expected args */)'
+      preferCalledWith: 'Prefer {{ matcherName }}With(/* expected args */)'
     },
     type: 'suggestion',
     schema: []
@@ -42,7 +42,7 @@ var _default = (0, _utils.createRule)({
         if (['toBeCalled', 'toHaveBeenCalled'].includes(matcher.name)) {
           context.report({
             data: {
-              name: matcher.name
+              matcherName: matcher.name
             },
             messageId: 'preferCalledWith',
             node: matcher.node.property

package/lib/rules/prefer-comparison-matcher.js

@@ -132,7 +132,7 @@ var _default = (0, _utils2.createRule)({
           data: {
             preferredMatcher
           },
-          node: (negation || matcher).node.property
+          node: matcher.node.property
         });
       }
 

package/lib/rules/prefer-equality-matcher.js

@@ -96,7 +96,7 @@ var _default = (0, _utils2.createRule)({
             },
             fix: buildFixer(equalityMatcher)
           })),
-          node: (negation || matcher).node.property
+          node: matcher.node.property
         });
       }
 

package/lib/rules/prefer-mock-promise-shorthand.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+const withOnce = (name, addOnce) => {
+  return `${name}${addOnce ? 'Once' : ''}`;
+};
+
+const findSingleReturnArgumentNode = fnNode => {
+  var _fnNode$body$body$;
+
+  if (fnNode.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+    return fnNode.body;
+  }
+
+  if (((_fnNode$body$body$ = fnNode.body.body[0]) === null || _fnNode$body$body$ === void 0 ? void 0 : _fnNode$body$body$.type) === _utils.AST_NODE_TYPES.ReturnStatement) {
+    return fnNode.body.body[0].argument;
+  }
+
+  return null;
+};
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer mock resolved/rejected shorthands for promises',
+      recommended: false
+    },
+    messages: {
+      useMockShorthand: 'Prefer {{ replacement }}'
+    },
+    schema: [],
+    type: 'suggestion',
+    fixable: 'code'
+  },
+  defaultOptions: [],
+
+  create(context) {
+    const report = (property, isOnce, outerArgNode, innerArgNode = outerArgNode) => {
+      if ((innerArgNode === null || innerArgNode === void 0 ? void 0 : innerArgNode.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+        return;
+      }
+
+      const argName = (0, _utils2.getNodeName)(innerArgNode);
+
+      if (argName !== 'Promise.resolve' && argName !== 'Promise.reject') {
+        return;
+      }
+
+      const replacement = withOnce(argName.endsWith('reject') ? 'mockRejectedValue' : 'mockResolvedValue', isOnce);
+      context.report({
+        node: property,
+        messageId: 'useMockShorthand',
+        data: {
+          replacement
+        },
+
+        fix(fixer) {
+          const sourceCode = context.getSourceCode(); // there shouldn't be more than one argument, but if there is don't try
+          // fixing since we have no idea what to do with the extra arguments
+
+          if (innerArgNode.arguments.length > 1) {
+            return null;
+          }
+
+          return [fixer.replaceText(property, replacement), fixer.replaceText(outerArgNode, // the value argument for both Promise methods is optional,
+          // whereas for Jest they're required so use an explicit undefined
+          // if no argument is being passed to the call we're replacing
+          innerArgNode.arguments.length === 1 ? sourceCode.getText(innerArgNode.arguments[0]) : 'undefined')];
+        }
+
+      });
+    };
+
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(node.callee.property) || node.arguments.length === 0) {
+          return;
+        }
+
+        const mockFnName = (0, _utils2.getAccessorValue)(node.callee.property);
+        const isOnce = mockFnName.endsWith('Once');
+
+        if (mockFnName === withOnce('mockReturnValue', isOnce)) {
+          report(node.callee.property, isOnce, node.arguments[0]);
+        } else if (mockFnName === withOnce('mockImplementation', isOnce)) {
+          const [arg] = node.arguments;
+
+          if (!(0, _utils2.isFunction)(arg)) {
+            return;
+          }
+
+          report(node.callee.property, isOnce, arg, findSingleReturnArgumentNode(arg));
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-to-contain.js

@@ -86,7 +86,7 @@ var _default = (0, _utils2.createRule)({
           },
 
           messageId: 'useToContain',
-          node: (modifier || matcher).node.property
+          node: matcher.node.property
         });
       }
 

package/lib/rules/valid-expect.js

@@ -26,7 +26,7 @@ const getPromiseCallExpressionNode = node => {
     node = node.parent;
   }
 
-  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object) && (0, _utils2.getAccessorValue)(node.callee.object) === 'Promise' && node.parent) {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object, 'Promise') && node.parent) {
     return node;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "26.6.0",
+  "version": "26.7.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -158,5 +158,5 @@
   "resolutions": {
     "@typescript-eslint/experimental-utils": "^5.0.0"
   },
-  "packageManager": "yarn@3.2.1"
+  "packageManager": "yarn@3.2.2"
 }