eslint-plugin-jest 22.15.0 → 22.17.0

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

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _util = require("./util");
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+
+var _utils = require("./utils");
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
 
@@ -15,84 +17,143 @@ function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d =
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-const isEqualityCheck = node => (0, _util.method)(node) && ((0, _util.method)(node).name === 'toBe' || (0, _util.method)(node).name === 'toEqual');
-
-const isArgumentValid = node => (0, _util.argument)(node).value === true || (0, _util.argument)(node).value === false;
-
-const hasOneArgument = node => node.arguments && node.arguments.length === 1;
-
-const isValidEqualityCheck = node => isEqualityCheck(node) && hasOneArgument(node.parent.parent) && isArgumentValid(node);
-
-const isEqualityNegation = node => (0, _util.method)(node).name === 'not' && isValidEqualityCheck(node.parent);
-
-const hasIncludesMethod = node => node.arguments[0] && node.arguments[0].callee && node.arguments[0].callee.property && node.arguments[0].callee.property.name === 'includes';
-
-const isValidIncludesMethod = node => hasIncludesMethod(node) && hasOneArgument(node.arguments[0]);
-
-const getNegationFixes = (node, sourceCode, fixer) => {
-  const negationPropertyDot = sourceCode.getFirstTokenBetween(node.parent.object, node.parent.property, token => token.value === '.');
-  const toContainFunc = isEqualityNegation(node) && (0, _util.argument)(node.parent).value ? 'not.toContain' : 'toContain'; //.includes function argument
-
-  const _node$arguments$0$arg = _slicedToArray(node.arguments[0].arguments, 1),
-        containArg = _node$arguments$0$arg[0];
+const isBooleanLiteral = node => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+
+/**
+ * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
+ * with a boolean literal as the sole argument.
+ *
+ * @example javascript
+ * toBe(true);
+ * toEqual(false);
+ *
+ * @param {ParsedExpectMatcher} matcher
+ *
+ * @return {matcher is ParsedBooleanEqualityMatcher}
+ */
+const isBooleanEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils.followTypeAssertionChain)(matcher.arguments[0]));
+
+/**
+ * Checks if the given `node` is a `CallExpression` representing the calling
+ * of an `includes`-like method that can be 'fixed' (using `toContain`).
+ *
+ * @param {CallExpression} node
+ *
+ * @return {node is FixableIncludesCallExpression}
+ *
+ * @todo support `['includes']()` syntax (remove last property.type check to begin)
+ * @todo break out into `isMethodCall<Name extends string>(node: TSESTree.Node, method: Name)` util-fn
+ */
+const isFixableIncludesCallExpression = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property, 'includes') && node.callee.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && (0, _utils.hasOnlyOneArgument)(node);
+
+const buildToContainFuncExpectation = negated => negated ? `${_utils.ModifierName.not}.toContain` : 'toContain';
+/**
+ * Finds the first `.` character token between the `object` & `property` of the given `member` expression.
+ *
+ * @param {TSESTree.MemberExpression} member
+ * @param {SourceCode} sourceCode
+ *
+ * @return {Token | null}
+ */
+
+
+const findPropertyDotToken = (member, sourceCode) => sourceCode.getFirstTokenBetween(member.object, member.property, token => token.value === '.');
+
+const getNegationFixes = (node, modifier, matcher, sourceCode, fixer, fileName) => {
+  const _node$arguments = _slicedToArray(node.arguments, 1),
+        containArg = _node$arguments[0];
+
+  const negationPropertyDot = findPropertyDotToken(modifier.node, sourceCode);
+  const toContainFunc = buildToContainFuncExpectation((0, _utils.followTypeAssertionChain)(matcher.arguments[0]).value);
+  /* istanbul ignore if */
+
+  if (negationPropertyDot === null) {
+    throw new Error(`Unexpected null when attempting to fix ${fileName} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
+  }
 
-  return [fixer.remove(negationPropertyDot), fixer.remove((0, _util.method)(node)), fixer.replaceText((0, _util.method)(node.parent), toContainFunc), fixer.replaceText((0, _util.argument)(node.parent), sourceCode.getText(containArg))];
+  return [fixer.remove(negationPropertyDot), fixer.remove(modifier.node.property), fixer.replaceText(matcher.node.property, toContainFunc), fixer.replaceText(matcher.arguments[0], sourceCode.getText(containArg))];
 };
 
-const getCommonFixes = (node, sourceCode, fixer) => {
-  const _node$arguments$0$arg2 = _slicedToArray(node.arguments[0].arguments, 1),
-        containArg = _node$arguments$0$arg2[0];
+const getCommonFixes = (node, sourceCode, fileName) => {
+  const _node$arguments2 = _slicedToArray(node.arguments, 1),
+        containArg = _node$arguments2[0];
 
-  const includesCaller = node.arguments[0].callee;
-  const propertyDot = sourceCode.getFirstTokenBetween(includesCaller.object, includesCaller.property, token => token.value === '.');
+  const includesCallee = node.callee;
+  const propertyDot = findPropertyDotToken(includesCallee, sourceCode);
   const closingParenthesis = sourceCode.getTokenAfter(containArg);
   const openParenthesis = sourceCode.getTokenBefore(containArg);
-  return [fixer.remove(containArg), fixer.remove(includesCaller.property), fixer.remove(propertyDot), fixer.remove(closingParenthesis), fixer.remove(openParenthesis)];
-};
+  /* istanbul ignore if */
+
+  if (propertyDot === null || closingParenthesis === null || openParenthesis === null) {
+    throw new Error(`Unexpected null when attempting to fix ${fileName} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
+  }
+
+  return [containArg, includesCallee.property, propertyDot, closingParenthesis, openParenthesis];
+}; // expect(array.includes(<value>)[not.]{toBe,toEqual}(<boolean>)
+
 
-var _default = {
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Suggest using `toContain()`',
+      recommended: false
     },
     messages: {
       useToContain: 'Use toContain() instead'
     },
     fixable: 'code',
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
       CallExpression(node) {
-        if (!((0, _util.expectResolvesCase)(node) || (0, _util.expectRejectsCase)(node)) && (0, _util.expectCaseWithParent)(node) && (isEqualityNegation(node) || isValidEqualityCheck(node)) && isValidIncludesMethod(node)) {
-          context.report({
-            fix(fixer) {
-              const sourceCode = context.getSourceCode();
-              let fixArr = getCommonFixes(node, sourceCode, fixer);
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
 
-              if (isEqualityNegation(node)) {
-                return getNegationFixes(node, sourceCode, fixer).concat(fixArr);
-              }
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              _parseExpectCall$expe = _slicedToArray(_parseExpectCall.expect.arguments, 1),
+              includesCall = _parseExpectCall$expe[0],
+              matcher = _parseExpectCall.matcher,
+              modifier = _parseExpectCall.modifier;
 
-              const toContainFunc = (0, _util.argument)(node).value ? 'toContain' : 'not.toContain'; //.includes function argument
+        if (!matcher || modifier && modifier.name !== _utils.ModifierName.not || !isBooleanEqualityMatcher(matcher) || !isFixableIncludesCallExpression(includesCall)) {
+          return;
+        }
 
-              const _node$arguments$0$arg3 = _slicedToArray(node.arguments[0].arguments, 1),
-                    containArg = _node$arguments$0$arg3[0];
+        context.report({
+          fix(fixer) {
+            const sourceCode = context.getSourceCode();
+            const fileName = context.getFilename();
+            const fixArr = getCommonFixes(includesCall, sourceCode, fileName).map(target => fixer.remove(target));
 
-              fixArr.push(fixer.replaceText((0, _util.method)(node), toContainFunc));
-              fixArr.push(fixer.replaceText((0, _util.argument)(node), sourceCode.getText(containArg)));
-              return fixArr;
-            },
+            if (modifier && modifier.name === _utils.ModifierName.not) {
+              return getNegationFixes(includesCall, modifier, matcher, sourceCode, fixer, fileName).concat(fixArr);
+            }
 
-            messageId: 'useToContain',
-            node: (0, _util.method)(node)
-          });
-        }
+            const toContainFunc = buildToContainFuncExpectation(!(0, _utils.followTypeAssertionChain)(matcher.arguments[0]).value);
+
+            const _includesCall$argumen = _slicedToArray(includesCall.arguments, 1),
+                  containArg = _includesCall$argumen[0];
+
+            fixArr.push(fixer.replaceText(matcher.node.property, toContainFunc));
+            fixArr.push(fixer.replaceText(matcher.arguments[0], sourceCode.getText(containArg)));
+            return fixArr;
+          },
+
+          messageId: 'useToContain',
+          node: (modifier || matcher).node.property
+        });
       }
 
     };
   }
 
-};
+});
+
 exports.default = _default;

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

@@ -5,38 +5,71 @@ 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");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+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; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
   meta: {
     docs: {
-      url: (0, _util.getDocsUrl)(__filename)
+      category: 'Best Practices',
+      description: 'Suggest using `toHaveLength()`',
+      recommended: false
     },
     messages: {
       useToHaveLength: 'Use toHaveLength() instead'
     },
     fixable: 'code',
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
       CallExpression(node) {
-        if (!((0, _util.expectNotCase)(node) || (0, _util.expectResolvesCase)(node) || (0, _util.expectRejectsCase)(node)) && (0, _util.expectCaseWithParent)(node) && ((0, _util.method)(node).name === 'toBe' || (0, _util.method)(node).name === 'toEqual') && node.arguments[0].property && node.arguments[0].property.name === 'length') {
-          const propertyDot = context.getSourceCode().getFirstTokenBetween(node.arguments[0].object, node.arguments[0].property, token => token.value === '.');
-          context.report({
-            fix(fixer) {
-              return [fixer.remove(propertyDot), fixer.remove(node.arguments[0].property), fixer.replaceText((0, _util.method)(node), 'toHaveLength')];
-            },
-
-            messageId: 'useToHaveLength',
-            node: (0, _util.method)(node)
-          });
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
+
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              _parseExpectCall$expe = _slicedToArray(_parseExpectCall.expect.arguments, 1),
+              argument = _parseExpectCall$expe[0],
+              matcher = _parseExpectCall.matcher;
+
+        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) {
+          return;
         }
+
+        context.report({
+          fix(fixer) {
+            const propertyDot = context.getSourceCode().getFirstTokenBetween(argument.object, argument.property, token => token.value === '.');
+            /* istanbul ignore if */
+
+            if (propertyDot === null) {
+              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`);
+            }
+
+            return [fixer.remove(propertyDot), fixer.remove(argument.property), fixer.replaceText(matcher.node.property, 'toHaveLength')];
+          },
+
+          messageId: 'useToHaveLength',
+          node: matcher.node.property
+        });
       }
 
     };
   }
 
-};
+});
+
 exports.default = _default;

package/lib/rules/prefer-todo.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(); }
 
@@ -17,12 +17,8 @@ function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d =
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-function isOnlyTestTitle(node) {
-  return node.arguments.length === 1;
-}
-
 function isFunctionBodyEmpty(node) {
-  /* istanbul ignore next https://github.com/typescript-eslint/typescript-eslint/issues/734 */
+  /* 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`);
   }
@@ -34,21 +30,17 @@ function isTestBodyEmpty(node) {
   const _node$arguments = _slicedToArray(node.arguments, 2),
         fn = _node$arguments[1];
 
-  return fn && (0, _tsUtils.isFunction)(fn) && isFunctionBodyEmpty(fn);
+  return fn && (0, _utils.isFunction)(fn) && isFunctionBodyEmpty(fn);
 }
 
 function addTodo(node, fixer) {
-  const testName = (0, _tsUtils.getNodeName)(node.callee).split('.').shift();
+  const testName = (0, _utils.getNodeName)(node.callee).split('.').shift();
   return fixer.replaceText(node.callee, `${testName}.todo`);
 }
 
-function isFirstArgString(node) {
-  return node.arguments[0] && (0, _tsUtils.isStringNode)(node.arguments[0]);
-}
+const isTargetedTestCase = node => (0, _utils.isTestCase)(node) && ['it', 'test', 'it.skip', 'test.skip'].includes((0, _utils.getNodeName)(node.callee));
 
-const isTargetedTestCase = node => (0, _tsUtils.isTestCase)(node) && ['it', 'test', 'it.skip', 'test.skip'].includes((0, _tsUtils.getNodeName)(node.callee));
-
-var _default = (0, _tsUtils.createRule)({
+var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -69,7 +61,11 @@ var _default = (0, _tsUtils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isTargetedTestCase(node) || !isFirstArgString(node)) {
+        const _node$arguments2 = _slicedToArray(node.arguments, 2),
+              firstArg = _node$arguments2[0],
+              secondArg = _node$arguments2[1];
+
+        if (!isTargetedTestCase(node) || !(0, _utils.isStringNode)(firstArg)) {
           return;
         }
 
@@ -77,11 +73,11 @@ var _default = (0, _tsUtils.createRule)({
           context.report({
             messageId: 'todoOverEmpty',
             node,
-            fix: fixer => [fixer.removeRange([node.arguments[0].range[1], node.arguments[1].range[1]]), addTodo(node, fixer)]
+            fix: fixer => [fixer.removeRange([firstArg.range[1], secondArg.range[1]]), addTodo(node, fixer)]
           });
         }
 
-        if (isOnlyTestTitle(node)) {
+        if ((0, _utils.hasOnlyOneArgument)(node)) {
           context.report({
             messageId: 'todoOverUnimplemented',
             node,

package/lib/rules/require-top-level-describe.js

@@ -0,0 +1,66 @@
+"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: {
+      category: 'Best Practices',
+      description: 'Prevents test cases and hooks to be outside of a describe block',
+      recommended: false
+    },
+    messages: {
+      unexpectedTestCase: 'All test cases must be wrapped in a describe block.',
+      unexpectedHook: 'All hooks must be wrapped in a describe block.'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    let numberOfDescribeBlocks = 0;
+    return {
+      CallExpression(node) {
+        if ((0, _utils.isDescribe)(node)) {
+          numberOfDescribeBlocks++;
+          return;
+        }
+
+        if (numberOfDescribeBlocks === 0) {
+          if ((0, _utils.isTestCase)(node)) {
+            context.report({
+              node,
+              messageId: 'unexpectedTestCase'
+            });
+            return;
+          }
+
+          if ((0, _utils.isHook)(node)) {
+            context.report({
+              node,
+              messageId: 'unexpectedHook'
+            });
+            return;
+          }
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isDescribe)(node)) {
+          numberOfDescribeBlocks--;
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/require-tothrow-message.js

@@ -5,41 +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: 'Require a message for `toThrow()`',
+      recommended: false
     },
     messages: {
       requireRethrow: 'Add an error message to {{ propertyName }}()'
     },
+    type: 'suggestion',
     schema: []
   },
+  defaultOptions: [],
 
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _util.expectCaseWithParent)(node)) {
+        if (!(0, _utils.isExpectCall)(node)) {
           return;
         }
 
-        let targetNode = (0, _util.method)(node);
+        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
+              matcher = _parseExpectCall.matcher,
+              modifier = _parseExpectCall.modifier;
 
-        if (targetNode.name === 'rejects') {
-          targetNode = (0, _util.method)(node.parent);
-        }
-
-        const propertyName = (0, _util.method)(targetNode) && (0, _util.method)(targetNode).name; // Look for `toThrow` calls with no arguments.
-
-        if (['toThrow', 'toThrowError'].includes(propertyName) && !(0, _util.argument)(targetNode)) {
+        if (matcher && matcher.arguments && 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: 'requireRethrow',
+            // todo: rename to 'addErrorMessage'
             data: {
-              propertyName
+              propertyName: matcher.name
             },
-            node: targetNode
+            // todo: rename to 'matcherName'
+            node: matcher.node.property
           });
         }
       }
@@ -47,5 +51,6 @@ var _default = {
     };
   }
 
-};
+});
+
 exports.default = _default;