eslint-plugin-jest 22.15.0 → 22.17.0

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

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -28,12 +28,12 @@ var _default = (0, _tsUtils.createRule)({
     let catchDepth = 0;
 
     function isThrowExpectCall(node) {
-      return catchDepth > 0 && (0, _tsUtils.isExpectCall)(node);
+      return catchDepth > 0 && (0, _utils.isExpectCall)(node);
     }
 
     return {
       CallExpression(node) {
-        if ((0, _tsUtils.isTestCase)(node)) {
+        if ((0, _utils.isTestCase)(node)) {
           isTest = true;
         } else if (isTest && isThrowExpectCall(node)) {
           context.report({
@@ -56,7 +56,7 @@ var _default = (0, _tsUtils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _tsUtils.isTestCase)(node)) {
+        if ((0, _utils.isTestCase)(node)) {
           isTest = false;
         }
       }

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

@@ -5,34 +5,45 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _utils = require("./utils");
 
-var _default = {
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Suggest using `toBeCalledWith()` OR `toHaveBeenCalledWith()`',
+      recommended: false
     },
     messages: {
       preferCalledWith: 'Prefer {{name}}With(/* expected args */)'
     },
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
       CallExpression(node) {
-        // Could check resolves/rejects here but not a likely idiom.
-        if ((0, _util.expectCaseWithParent)(node) && !(0, _util.expectNotCase)(node)) {
-          const methodNode = (0, _util.method)(node);
-          const name = methodNode.name;
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
+
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              modifier = _parseExpectCall.modifier,
+              matcher = _parseExpectCall.matcher; // Could check resolves/rejects here but not a likely idiom.
+
 
-          if (name === 'toBeCalled' || name === 'toHaveBeenCalled') {
+        if (matcher && !modifier) {
+          if (['toBeCalled', 'toHaveBeenCalled'].includes(matcher.name)) {
             context.report({
               data: {
-                name
+                name: matcher.name
               },
+              // todo: rename to 'matcherName'
               messageId: 'preferCalledWith',
-              node: methodNode
+              node: matcher.node.property
             });
           }
         }
@@ -41,5 +52,6 @@ var _default = {
     };
   }
 
-};
+});
+
 exports.default = _default;

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

@@ -5,70 +5,81 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-const validateArguments = expression => {
-  return expression.arguments && expression.arguments.length === 1 && Number.isInteger(expression.arguments[0].value);
-};
+var _utils = require("./utils");
 
-const isExpectAssertionsOrHasAssertionsCall = expression => {
-  try {
-    const expectAssertionOrHasAssertionCall = expression.type === 'CallExpression' && expression.callee.type === 'MemberExpression' && expression.callee.object.name === 'expect' && (expression.callee.property.name === 'assertions' || expression.callee.property.name === 'hasAssertions');
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
 
-    if (expression.callee.property.name === 'assertions') {
-      return expectAssertionOrHasAssertionCall && validateArguments(expression);
-    }
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
-    return expectAssertionOrHasAssertionCall;
-  } catch (e) {
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+const isExpectAssertionsOrHasAssertionsCall = expression => {
+  if (expression.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression || expression.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || !(0, _utils.isSupportedAccessor)(expression.callee.object, 'expect') || !(0, _utils.isSupportedAccessor)(expression.callee.property)) {
     return false;
   }
-};
 
-const getFunctionFirstLine = functionBody => {
-  return functionBody[0] && functionBody[0].expression;
-};
+  const expectAssertionName = (0, _utils.getAccessorValue)(expression.callee.property);
 
-const isFirstLineExprStmt = functionBody => {
-  return functionBody[0] && functionBody[0].type === 'ExpressionStatement';
-};
+  if (expectAssertionName !== 'assertions') {
+    return expectAssertionName === 'hasAssertions';
+  }
 
-const reportMsg = (context, node) => {
-  context.report({
-    messageId: 'haveExpectAssertions',
-    node
-  });
+  const _expression$arguments = _slicedToArray(expression.arguments, 1),
+        arg = _expression$arguments[0];
+
+  return expression.arguments && expression.arguments.length === 1 && arg.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof arg.value === 'number' && Number.isInteger(arg.value);
 };
 
-var _default = {
+const getFunctionFirstLine = functionBody => functionBody[0] && functionBody[0].expression;
+
+const isFirstLineExprStmt = functionBody => functionBody[0] && functionBody[0].type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement;
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Suggest using `expect.assertions()` OR `expect.hasAssertions()`',
+      recommended: false
     },
     messages: {
       haveExpectAssertions: 'Every test should have either `expect.assertions(<number of assertions>)` or `expect.hasAssertions()` as its first expression'
     },
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
       'CallExpression[callee.name=/^(it|test)$/][arguments.1.body.body]'(node) {
         const testFuncBody = node.arguments[1].body.body;
 
-        if (isFirstLineExprStmt(testFuncBody)) {
-          const testFuncFirstLine = getFunctionFirstLine(testFuncBody);
+        if (!isFirstLineExprStmt(testFuncBody)) {
+          context.report({
+            messageId: 'haveExpectAssertions',
+            node
+          });
+          return;
+        }
+
+        const testFuncFirstLine = getFunctionFirstLine(testFuncBody);
 
-          if (!isExpectAssertionsOrHasAssertionsCall(testFuncFirstLine)) {
-            reportMsg(context, node);
-          }
-        } else {
-          reportMsg(context, node);
+        if (!isExpectAssertionsOrHasAssertionsCall(testFuncFirstLine)) {
+          context.report({
+            messageId: 'haveExpectAssertions',
+            node
+          });
         }
       }
 
     };
   }
 
-};
+});
+
 exports.default = _default;

package/lib/rules/prefer-inline-snapshots.js

@@ -7,9 +7,9 @@ exports.default = void 0;
 
 var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {

package/lib/rules/prefer-spy-on.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 
 var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
 
@@ -41,13 +41,13 @@ const getJestFnCall = node => {
   }
 
   if (obj.type === _experimentalUtils.AST_NODE_TYPES.Identifier) {
-    return node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _tsUtils.getNodeName)(node.callee) === 'jest.fn' ? node : null;
+    return node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.getNodeName)(node.callee) === 'jest.fn' ? node : null;
   }
 
   return getJestFnCall(obj);
 };
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -83,7 +83,7 @@ var _default = (0, _tsUtils.createRule)({
                   arg = _jestFnCall$arguments[0];
 
             const argSource = arg && context.getSourceCode().getText(arg);
-            const mockImplementation = argSource ? `.mockImplementation(${argSource})` : '';
+            const mockImplementation = argSource ? `.mockImplementation(${argSource})` : '.mockImplementation()';
             return [fixer.insertTextBefore(left, `jest.spyOn(`), fixer.replaceTextRange([left.object.range[1], left.property.range[0]], `, ${leftPropQuote}`), fixer.replaceTextRange([left.property.range[1], jestFnCall.range[1]], `${leftPropQuote})${mockImplementation}`)];
           }
 

package/lib/rules/prefer-strict-equal.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _tsUtils = require("./tsUtils");
+var _utils = require("./utils");
 
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -19,28 +19,26 @@ var _default = (0, _tsUtils.createRule)({
       useToStrictEqual: 'Use toStrictEqual() instead'
     },
     fixable: 'code',
-    schema: [],
-    type: 'suggestion'
+    type: 'suggestion',
+    schema: []
   },
   defaultOptions: [],
 
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _tsUtils.isExpectCallWithParent)(node)) {
+        if (!(0, _utils.isExpectCall)(node)) {
           return;
         }
 
-        const methodNode = node.parent.property;
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              matcher = _parseExpectCall.matcher;
 
-        if (methodNode && methodNode.name === 'toEqual') {
+        if (matcher && matcher.name === 'toEqual') {
           context.report({
-            fix(fixer) {
-              return [fixer.replaceText(methodNode, 'toStrictEqual')];
-            },
-
+            fix: fixer => [fixer.replaceText(matcher.node.property, 'toStrictEqual')],
             messageId: 'useToStrictEqual',
-            node: methodNode
+            node: matcher.node.property
           });
         }
       }

package/lib/rules/prefer-to-be-null.js

@@ -5,38 +5,55 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-var _default = {
+var _utils = require("./utils");
+
+const isNullLiteral = node => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && node.value === null;
+/**
+ * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
+ * with a `null` literal as the sole argument.
+ *
+ * @param {ParsedExpectMatcher} matcher
+ *
+ * @return {matcher is ParsedEqualityMatcherCall<MaybeTypeCast<NullLiteral>>}
+ */
+
+
+const isNullEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCall)(matcher) && isNullLiteral((0, _utils.followTypeAssertionChain)(matcher.arguments[0]));
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Suggest using `toBeNull()`',
+      recommended: false
     },
     messages: {
       useToBeNull: 'Use toBeNull() instead'
     },
     fixable: 'code',
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
       CallExpression(node) {
-        const is = (0, _util.expectToBeCase)(node, null) || (0, _util.expectToEqualCase)(node, null);
-        const isNot = (0, _util.expectNotToEqualCase)(node, null) || (0, _util.expectNotToBeCase)(node, null);
-
-        if (is || isNot) {
-          context.report({
-            fix(fixer) {
-              if (is) {
-                return [fixer.replaceText((0, _util.method)(node), 'toBeNull'), fixer.remove((0, _util.argument)(node))];
-              }
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
 
-              return [fixer.replaceText((0, _util.method2)(node), 'toBeNull'), fixer.remove((0, _util.argument2)(node))];
-            },
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              matcher = _parseExpectCall.matcher;
 
+        if (matcher && isNullEqualityMatcher(matcher)) {
+          context.report({
+            fix: fixer => [fixer.replaceText(matcher.node.property, 'toBeNull'), fixer.remove(matcher.arguments[0])],
             messageId: 'useToBeNull',
-            node: is ? (0, _util.method)(node) : (0, _util.method2)(node)
+            node: matcher.node.property
           });
         }
       }
@@ -44,5 +61,6 @@ var _default = {
     };
   }
 
-};
+});
+
 exports.default = _default;

package/lib/rules/prefer-to-be-undefined.js

@@ -5,38 +5,55 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
-var _default = {
+var _utils = require("./utils");
+
+const isUndefinedIdentifier = node => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && node.name === 'undefined';
+/**
+ * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
+ * with a `undefined` identifier as the sole argument.
+ *
+ * @param {ParsedExpectMatcher} matcher
+ *
+ * @return {matcher is ParsedEqualityMatcherCall<MaybeTypeCast<UndefinedIdentifier>>}
+ */
+
+
+const isUndefinedEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCall)(matcher) && isUndefinedIdentifier((0, _utils.followTypeAssertionChain)(matcher.arguments[0]));
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Suggest using `toBeUndefined()`',
+      recommended: false
     },
     messages: {
       useToBeUndefined: 'Use toBeUndefined() instead'
     },
     fixable: 'code',
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
       CallExpression(node) {
-        const is = (0, _util.expectToBeCase)(node, undefined) || (0, _util.expectToEqualCase)(node, undefined);
-        const isNot = (0, _util.expectNotToEqualCase)(node, undefined) || (0, _util.expectNotToBeCase)(node, undefined);
-
-        if (is || isNot) {
-          context.report({
-            fix(fixer) {
-              if (is) {
-                return [fixer.replaceText((0, _util.method)(node), 'toBeUndefined'), fixer.remove((0, _util.argument)(node))];
-              }
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
 
-              return [fixer.replaceText((0, _util.method2)(node), 'toBeUndefined'), fixer.remove((0, _util.argument2)(node))];
-            },
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              matcher = _parseExpectCall.matcher;
 
+        if (matcher && isUndefinedEqualityMatcher(matcher)) {
+          context.report({
+            fix: fixer => [fixer.replaceText(matcher.node.property, 'toBeUndefined'), fixer.remove(matcher.arguments[0])],
             messageId: 'useToBeUndefined',
-            node: is ? (0, _util.method)(node) : (0, _util.method2)(node)
+            node: matcher.node.property
           });
         }
       }
@@ -44,5 +61,6 @@ var _default = {
     };
   }
 
-};
+});
+
 exports.default = _default;