eslint-plugin-jest 25.0.0-next.4 → 25.0.0

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+
+var _utils = require("./utils");
+
+const isNullLiteral = node => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && node.value === null;
+/**
+ * Checks if the given `ParsedEqualityMatcherCall` is a call to one of the equality matchers,
+ * with a `null` literal as the sole argument.
+ */
+
+
+const isNullEqualityMatcher = matcher => isNullLiteral(getFirstArgument(matcher));
+
+const isFirstArgumentIdentifier = (matcher, name) => (0, _utils.isIdentifier)(getFirstArgument(matcher), name);
+
+const isPrimitiveLiteral = matcher => {
+  const firstArg = getFirstArgument(matcher);
+  return firstArg.type === _experimentalUtils.AST_NODE_TYPES.Literal && !('regex' in firstArg);
+};
+
+const getFirstArgument = matcher => {
+  return (0, _utils.followTypeAssertionChain)(matcher.arguments[0]);
+};
+
+const reportPreferToBe = (context, whatToBe, matcher, modifier) => {
+  const modifierNode = (modifier === null || modifier === void 0 ? void 0 : modifier.negation) || (modifier === null || modifier === void 0 ? void 0 : modifier.node);
+  context.report({
+    messageId: `useToBe${whatToBe}`,
+
+    fix(fixer) {
+      var _matcher$arguments;
+
+      const fixes = [fixer.replaceText(matcher.node.property, `toBe${whatToBe}`)];
+
+      if ((_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length && whatToBe !== '') {
+        fixes.push(fixer.remove(matcher.arguments[0]));
+      }
+
+      if (modifierNode) {
+        fixes.push(fixer.removeRange([modifierNode.property.range[0] - 1, modifierNode.property.range[1]]));
+      }
+
+      return fixes;
+    },
+
+    node: matcher.node.property
+  });
+};
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Suggest using `toBe()` for primitive literals',
+      recommended: false
+    },
+    messages: {
+      useToBe: 'Use `toBe` when expecting primitive literals',
+      useToBeUndefined: 'Use `toBeUndefined` instead',
+      useToBeDefined: 'Use `toBeDefined` instead',
+      useToBeNull: 'Use `toBeNull` instead',
+      useToBeNaN: 'Use `toBeNaN` instead'
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
+
+        const {
+          matcher,
+          modifier
+        } = (0, _utils.parseExpectCall)(node);
+
+        if (!matcher) {
+          return;
+        }
+
+        if (((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation) && ['toBeUndefined', 'toBeDefined'].includes(matcher.name)) {
+          reportPreferToBe(context, matcher.name === 'toBeDefined' ? 'Undefined' : 'Defined', matcher, modifier);
+          return;
+        }
+
+        if (!(0, _utils.isParsedEqualityMatcherCall)(matcher)) {
+          return;
+        }
+
+        if (isNullEqualityMatcher(matcher)) {
+          reportPreferToBe(context, 'Null', matcher);
+          return;
+        }
+
+        if (isFirstArgumentIdentifier(matcher, 'undefined')) {
+          const name = (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation ? 'Defined' : 'Undefined';
+          reportPreferToBe(context, name, matcher, modifier);
+          return;
+        }
+
+        if (isFirstArgumentIdentifier(matcher, 'NaN')) {
+          reportPreferToBe(context, 'NaN', matcher);
+          return;
+        }
+
+        if (isPrimitiveLiteral(matcher) && matcher.name !== _utils.EqualityMatcher.toBe) {
+          reportPreferToBe(context, '', matcher);
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/require-hook.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+
+var _utils = require("./utils");
+
+const isJestFnCall = node => {
+  var _getNodeName;
+
+  if ((0, _utils.isDescribeCall)(node) || (0, _utils.isTestCaseCall)(node) || (0, _utils.isHook)(node)) {
+    return true;
+  }
+
+  return !!((_getNodeName = (0, _utils.getNodeName)(node)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith('jest.'));
+};
+
+const shouldBeInHook = node => {
+  switch (node.type) {
+    case _experimentalUtils.AST_NODE_TYPES.ExpressionStatement:
+      return shouldBeInHook(node.expression);
+
+    case _experimentalUtils.AST_NODE_TYPES.CallExpression:
+      return !isJestFnCall(node);
+
+    default:
+      return false;
+  }
+};
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Require setup and teardown code to be within a hook',
+      recommended: false
+    },
+    messages: {
+      useHook: 'This should be done within a hook'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    const checkBlockBody = body => {
+      for (const statement of body) {
+        if (shouldBeInHook(statement)) {
+          context.report({
+            node: statement,
+            messageId: 'useHook'
+          });
+        }
+      }
+    };
+
+    return {
+      Program(program) {
+        checkBlockBody(program.body);
+      },
+
+      CallExpression(node) {
+        if (!(0, _utils.isDescribeCall)(node) || node.arguments.length < 2) {
+          return;
+        }
+
+        const [, testFn] = node.arguments;
+
+        if (!(0, _utils.isFunction)(testFn) || testFn.body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+          return;
+        }
+
+        checkBlockBody(testFn.body.body);
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

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

@@ -7,6 +7,12 @@ exports.default = void 0;
 
 var _utils = require("./utils");
 
+const messages = {
+  tooManyDescribes: 'There should not be more than {{ max }} describe{{ s }} at the top level',
+  unexpectedTestCase: 'All test cases must be wrapped in a describe block.',
+  unexpectedHook: 'All hooks must be wrapped in a describe block.'
+};
+
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -15,21 +21,49 @@ var _default = (0, _utils.createRule)({
       description: 'Require test cases and hooks to be inside 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.'
-    },
+    messages,
     type: 'suggestion',
-    schema: []
+    schema: [{
+      type: 'object',
+      properties: {
+        maxNumberOfTopLevelDescribes: {
+          type: 'number',
+          minimum: 1
+        }
+      },
+      additionalProperties: false
+    }]
   },
-  defaultOptions: [],
+  defaultOptions: [{}],
 
   create(context) {
+    var _context$options$;
+
+    const {
+      maxNumberOfTopLevelDescribes = Infinity
+    } = (_context$options$ = context.options[0]) !== null && _context$options$ !== void 0 ? _context$options$ : {};
+    let numberOfTopLevelDescribeBlocks = 0;
     let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
         if ((0, _utils.isDescribeCall)(node)) {
           numberOfDescribeBlocks++;
+
+          if (numberOfDescribeBlocks === 1) {
+            numberOfTopLevelDescribeBlocks++;
+
+            if (numberOfTopLevelDescribeBlocks > maxNumberOfTopLevelDescribes) {
+              context.report({
+                node,
+                messageId: 'tooManyDescribes',
+                data: {
+                  max: maxNumberOfTopLevelDescribes,
+                  s: maxNumberOfTopLevelDescribes === 1 ? '' : 's'
+                }
+              });
+            }
+          }
+
           return;
         }
 

package/lib/rules/utils.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getNodeName = getNodeName;
-exports.scopeHasLocalReference = exports.isDescribeCall = exports.isTestCaseCall = exports.getTestCallExpressionsFromDeclaredVariables = exports.isHook = exports.isFunction = exports.TestCaseProperty = exports.DescribeProperty = exports.HookName = exports.TestCaseName = exports.DescribeAlias = exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.EqualityMatcher = exports.ModifierName = exports.isExpectMember = exports.isExpectCall = exports.getAccessorValue = exports.isSupportedAccessor = exports.hasOnlyOneArgument = exports.getStringValue = exports.isStringNode = exports.followTypeAssertionChain = exports.createRule = void 0;
+exports.scopeHasLocalReference = exports.isDescribeCall = exports.isTestCaseCall = exports.getTestCallExpressionsFromDeclaredVariables = exports.isHook = exports.isFunction = exports.TestCaseProperty = exports.DescribeProperty = exports.HookName = exports.TestCaseName = exports.DescribeAlias = exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.EqualityMatcher = exports.ModifierName = exports.isExpectMember = exports.isExpectCall = exports.getAccessorValue = exports.isSupportedAccessor = exports.isIdentifier = exports.hasOnlyOneArgument = exports.getStringValue = exports.isStringNode = exports.followTypeAssertionChain = exports.createRule = void 0;
 
 var _path = require("path");
 
@@ -151,6 +151,8 @@ const isIdentifier = (node, name) => node.type === _experimentalUtils.AST_NODE_T
  */
 
 
+exports.isIdentifier = isIdentifier;
+
 const isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStringNode(node, value);
 /**
  * Gets the value of the given `AccessorNode`,
@@ -231,7 +233,7 @@ const reparseAsMatcher = parsedMember => ({ ...parsedMember,
    *
    * If this matcher isn't called, this will be `null`.
    */
-  arguments: parsedMember.node.parent && parsedMember.node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
+  arguments: parsedMember.node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
 });
 /**
  * Re-parses the given `parsedMember` as a `ParsedExpectModifier`.
@@ -258,7 +260,7 @@ const reparseMemberAsModifier = parsedMember => {
     throw new Error(`modifier name must be either "${ModifierName.resolves}" or "${ModifierName.rejects}" (got "${parsedMember.name}")`);
   }
 
-  const negation = parsedMember.node.parent && isExpectMember(parsedMember.node.parent, ModifierName.not) ? parsedMember.node.parent : undefined;
+  const negation = isExpectMember(parsedMember.node.parent, ModifierName.not) ? parsedMember.node.parent : undefined;
   return { ...parsedMember,
     negation
   };
@@ -295,7 +297,7 @@ const parseExpectCall = expect => {
   const modifier = expectation.modifier = reparseMemberAsModifier(parsedMember);
   const memberNode = modifier.negation || modifier.node;
 
-  if (!memberNode.parent || !isExpectMember(memberNode.parent)) {
+  if (!isExpectMember(memberNode.parent)) {
     return expectation;
   }