@depup/eslint-plugin-jest 29.15.1-depup.0

package/lib/rules/prefer-ending-with-an-expect.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+/*
+ * This implementation is adapted from eslint-plugin-jasmine.
+ * MIT license, Remco Haszing.
+ */
+
+/**
+ * Checks if node names returned by getNodeName matches any of the given star patterns
+ * Pattern examples:
+ *   request.*.expect
+ *   request.**.expect
+ *   request.**.expect*
+ */
+function matchesAssertFunctionName(nodeName, patterns) {
+  return patterns.some(p => new RegExp(`^${p.split('.').map(x => {
+    if (x === '**') {
+      return '[a-z\\d\\.]*';
+    }
+    return x.replace(/\*/gu, '[a-z\\d]*');
+  }).join('\\.')}(\\.|$)`, 'ui').test(nodeName));
+}
+function getLastStatement(fn) {
+  if (fn.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
+    if (fn.body.body.length === 0) {
+      return null;
+    }
+    const lastStatement = fn.body.body[fn.body.body.length - 1];
+    if (lastStatement.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
+      return lastStatement.expression;
+    }
+    return lastStatement;
+  }
+  return fn.body;
+}
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer having the last statement in a test be an assertion'
+    },
+    messages: {
+      mustEndWithExpect: 'Tests should end with an assertion'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        assertFunctionNames: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        },
+        additionalTestBlockFunctions: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    }],
+    type: 'suggestion'
+  },
+  defaultOptions: [{
+    assertFunctionNames: ['expect'],
+    additionalTestBlockFunctions: []
+  }],
+  create(context, [{
+    assertFunctionNames = ['expect'],
+    additionalTestBlockFunctions = []
+  }]) {
+    return {
+      CallExpression(node) {
+        const name = (0, _utils2.getNodeName)(node.callee) ?? '';
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) && !additionalTestBlockFunctions.includes(name)) {
+          return;
+        }
+        if (node.arguments.length < 2 || !(0, _utils2.isFunction)(node.arguments[1])) {
+          return;
+        }
+        let lastStatement = getLastStatement(node.arguments[1]);
+        if (lastStatement?.type === _utils.AST_NODE_TYPES.AwaitExpression) {
+          lastStatement = lastStatement.argument;
+        }
+        if (lastStatement?.type === _utils.AST_NODE_TYPES.CallExpression && ((0, _utils2.isTypeOfJestFnCall)(lastStatement, context, ['expect']) || matchesAssertFunctionName((0, _utils2.getNodeName)(lastStatement.callee), assertFunctionNames))) {
+          return;
+        }
+        context.report({
+          messageId: 'mustEndWithExpect',
+          node: node.callee
+        });
+      }
+    };
+  }
+});

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

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest using the built-in equality matchers'
+    },
+    messages: {
+      useEqualityMatcher: 'Prefer using one of the equality matchers instead',
+      suggestEqualityMatcher: 'Use `{{ equalityMatcher }}`'
+    },
+    hasSuggestions: true,
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect' || jestFnCall.args.length === 0) {
+          return;
+        }
+        const {
+          parent: expect
+        } = jestFnCall.head.node;
+        if (expect.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+        const {
+          arguments: [comparison],
+          range: [, expectCallEnd]
+        } = expect;
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
+        if (comparison.type !== _utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== '===' && comparison.operator !== '!==' || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg)) {
+          return;
+        }
+        const matcherValue = matcherArg.value;
+        const [modifier] = jestFnCall.modifiers;
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+
+        // we need to negate the expectation if the current expected
+        // value is itself negated by the "not" modifier
+        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === hasNot;
+        const buildFixer = equalityMatcher => fixer => {
+          const {
+            sourceCode
+          } = context;
+
+          // preserve the existing modifier if it's not a negation
+          let modifierText = modifier && (0, _utils2.getAccessorValue)(modifier) !== 'not' ? `.${(0, _utils2.getAccessorValue)(modifier)}` : '';
+          if (addNotModifier) {
+            modifierText += `.${_utils2.ModifierName.not}`;
+          }
+          return [
+          // replace the comparison argument with the left-hand side of the comparison
+          fixer.replaceText(comparison, sourceCode.getText(comparison.left)),
+          // replace the current matcher & modifier with the preferred matcher
+          fixer.replaceTextRange([expectCallEnd, matcher.parent.range[1]], `${modifierText}.${equalityMatcher}`),
+          // replace the matcher argument with the right-hand side of the comparison
+          fixer.replaceText(matcherArg, sourceCode.getText(comparison.right))];
+        };
+        context.report({
+          messageId: 'useEqualityMatcher',
+          suggest: ['toBe', 'toEqual', 'toStrictEqual'].map(equalityMatcher => ({
+            messageId: 'suggestEqualityMatcher',
+            data: {
+              equalityMatcher
+            },
+            fix: buildFixer(equalityMatcher)
+          })),
+          node: matcher
+        });
+      }
+    };
+  }
+});

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

@@ -0,0 +1,237 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const isFirstStatement = node => {
+  let parent = node;
+  while (parent) {
+    if (parent.parent?.type === _utils.AST_NODE_TYPES.BlockStatement) {
+      return parent.parent.body[0] === parent;
+    }
+
+    // if we've hit an arrow function, then it must have a single expression
+    // as its body, as otherwise we would have hit the block statement already
+    if (parent.parent?.type === _utils.AST_NODE_TYPES.ArrowFunctionExpression) {
+      return true;
+    }
+    parent = parent.parent;
+  }
+
+  /* istanbul ignore next */
+  throw new Error(`Could not find BlockStatement - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
+};
+const suggestRemovingExtraArguments = (context, func, from) => ({
+  messageId: 'suggestRemovingExtraArguments',
+  fix: fixer => (0, _utils2.removeExtraArgumentsFixer)(fixer, context, func, from)
+});
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest using `expect.assertions()` OR `expect.hasAssertions()`'
+    },
+    messages: {
+      hasAssertionsTakesNoArguments: '`expect.hasAssertions` expects no arguments',
+      assertionsRequiresOneArgument: '`expect.assertions` expects a single argument of type number',
+      assertionsRequiresNumberArgument: 'This argument should be a number',
+      haveExpectAssertions: 'Every test should have either `expect.assertions(<number of assertions>)` or `expect.hasAssertions()` as its first expression',
+      suggestAddingHasAssertions: 'Add `expect.hasAssertions()`',
+      suggestAddingAssertions: 'Add `expect.assertions(<number of assertions>)`',
+      suggestRemovingExtraArguments: 'Remove extra arguments'
+    },
+    type: 'suggestion',
+    hasSuggestions: true,
+    schema: [{
+      type: 'object',
+      properties: {
+        onlyFunctionsWithAsyncKeyword: {
+          type: 'boolean'
+        },
+        onlyFunctionsWithExpectInLoop: {
+          type: 'boolean'
+        },
+        onlyFunctionsWithExpectInCallback: {
+          type: 'boolean'
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    onlyFunctionsWithAsyncKeyword: false,
+    onlyFunctionsWithExpectInLoop: false,
+    onlyFunctionsWithExpectInCallback: false
+  }],
+  create(context, [options]) {
+    let expressionDepth = 0;
+    let describeDepth = 0;
+    let hasExpectInCallback = false;
+    let hasExpectInLoop = false;
+    let hasExpectAssertionsAsFirstStatement = false;
+    let inTestCaseCall = false;
+    let inForLoop = false;
+    const shouldCheckFunction = testFunction => {
+      if (!options.onlyFunctionsWithAsyncKeyword && !options.onlyFunctionsWithExpectInLoop && !options.onlyFunctionsWithExpectInCallback) {
+        return true;
+      }
+      if (options.onlyFunctionsWithAsyncKeyword) {
+        if (testFunction.async) {
+          return true;
+        }
+      }
+      if (options.onlyFunctionsWithExpectInLoop) {
+        if (hasExpectInLoop) {
+          return true;
+        }
+      }
+      if (options.onlyFunctionsWithExpectInCallback) {
+        if (hasExpectInCallback) {
+          return true;
+        }
+      }
+      return false;
+    };
+    const checkExpectHasAssertions = (expectFnCall, func) => {
+      if ((0, _utils2.getAccessorValue)(expectFnCall.members[0]) === 'hasAssertions') {
+        if (expectFnCall.args.length) {
+          context.report({
+            messageId: 'hasAssertionsTakesNoArguments',
+            node: expectFnCall.matcher,
+            suggest: [suggestRemovingExtraArguments(context, func, 0)]
+          });
+        }
+        return;
+      }
+      if (expectFnCall.args.length !== 1) {
+        let {
+          loc
+        } = expectFnCall.matcher;
+        const suggest = [];
+        if (expectFnCall.args.length) {
+          loc = expectFnCall.args[1].loc;
+          suggest.push(suggestRemovingExtraArguments(context, func, 1));
+        }
+        context.report({
+          messageId: 'assertionsRequiresOneArgument',
+          suggest,
+          loc
+        });
+        return;
+      }
+      const [arg] = expectFnCall.args;
+      if (arg.type === _utils.AST_NODE_TYPES.Literal && Number.isInteger(arg.value)) {
+        return;
+      }
+      context.report({
+        messageId: 'assertionsRequiresNumberArgument',
+        node: arg
+      });
+    };
+    const enterExpression = () => inTestCaseCall && expressionDepth++;
+    const exitExpression = () => inTestCaseCall && expressionDepth--;
+    const enterForLoop = () => inForLoop = true;
+    const exitForLoop = () => inForLoop = false;
+    let inEachHook = false;
+
+    // when set to a non-negative value, all expect calls within describes whose depth
+    // are equal to or higher than this value are covered by an expect.hasAssertions set
+    // up within a beforeEach or afterEach hook
+    //
+    // when the describe depth is lower than the current value, it gets reset to -1
+    let coveredByHookAtDepth = -1;
+    return {
+      FunctionExpression: enterExpression,
+      'FunctionExpression:exit': exitExpression,
+      ArrowFunctionExpression: enterExpression,
+      'ArrowFunctionExpression:exit': exitExpression,
+      ForStatement: enterForLoop,
+      'ForStatement:exit': exitForLoop,
+      ForInStatement: enterForLoop,
+      'ForInStatement:exit': exitForLoop,
+      ForOfStatement: enterForLoop,
+      'ForOfStatement:exit': exitForLoop,
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type === 'describe') {
+          describeDepth += 1;
+        }
+        if (jestFnCall?.type === 'hook' && jestFnCall.name.endsWith('Each')) {
+          inEachHook = true;
+        }
+        if (jestFnCall?.type === 'test') {
+          inTestCaseCall = true;
+          return;
+        }
+        if (jestFnCall?.type === 'expect' && inEachHook && (0, _utils2.getAccessorValue)(jestFnCall.members[0]) === 'hasAssertions') {
+          checkExpectHasAssertions(jestFnCall, node);
+          if (coveredByHookAtDepth < 0) {
+            coveredByHookAtDepth = describeDepth;
+          }
+        }
+        if (jestFnCall?.type === 'expect' && inTestCaseCall) {
+          if (expressionDepth === 1 && isFirstStatement(node) && ['assertions', 'hasAssertions'].includes((0, _utils2.getAccessorValue)(jestFnCall.members[0]))) {
+            checkExpectHasAssertions(jestFnCall, node);
+            hasExpectAssertionsAsFirstStatement = true;
+          }
+          if (inForLoop) {
+            hasExpectInLoop = true;
+          }
+          if (expressionDepth > 1) {
+            hasExpectInCallback = true;
+          }
+        }
+      },
+      'CallExpression:exit'(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type === 'describe') {
+          describeDepth -= 1;
+
+          // clear the "covered by each hook" flag if we have left the describe
+          // depth that it applies to
+          if (coveredByHookAtDepth > describeDepth) {
+            coveredByHookAtDepth = -1;
+          }
+        }
+        if (jestFnCall?.type === 'hook' && jestFnCall.name.endsWith('Each')) {
+          inEachHook = false;
+        }
+        if (jestFnCall?.type !== 'test') {
+          return;
+        }
+        inTestCaseCall = false;
+        if (node.arguments.length < 2) {
+          return;
+        }
+        const [, testFn] = node.arguments;
+        if (!(0, _utils2.isFunction)(testFn) || !shouldCheckFunction(testFn)) {
+          return;
+        }
+        hasExpectInLoop = false;
+        hasExpectInCallback = false;
+        if (hasExpectAssertionsAsFirstStatement) {
+          hasExpectAssertionsAsFirstStatement = false;
+          return;
+        }
+        if (coveredByHookAtDepth >= 0 && coveredByHookAtDepth <= describeDepth) {
+          return;
+        }
+        const suggestions = [];
+        if (testFn.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
+          suggestions.push(['suggestAddingHasAssertions', 'expect.hasAssertions();'], ['suggestAddingAssertions', 'expect.assertions();']);
+        }
+        context.report({
+          messageId: 'haveExpectAssertions',
+          node,
+          suggest: suggestions.map(([messageId, text]) => ({
+            messageId,
+            fix: fixer => fixer.insertTextBeforeRange([testFn.body.range[0] + 1, testFn.body.range[1]], text)
+          }))
+        });
+      }
+    };
+  }
+});

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

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer `await expect(...).resolves` over `expect(await ...)` syntax'
+    },
+    fixable: 'code',
+    messages: {
+      expectResolves: 'Use `await expect(...).resolves instead'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create: context => ({
+    CallExpression(node) {
+      const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+      if (jestFnCall?.type !== 'expect') {
+        return;
+      }
+      const {
+        parent
+      } = jestFnCall.head.node;
+      if (parent.type !== _utils.AST_NODE_TYPES.CallExpression) {
+        return;
+      }
+      const [awaitNode] = parent.arguments;
+      if (awaitNode.type === _utils.AST_NODE_TYPES.AwaitExpression) {
+        context.report({
+          node: awaitNode,
+          messageId: 'expectResolves',
+          fix(fixer) {
+            return [fixer.insertTextBefore(parent, 'await '), fixer.removeRange([awaitNode.range[0], awaitNode.argument.range[0]]), fixer.insertTextAfter(parent, '.resolves')];
+          }
+        });
+      }
+    }
+  })
+});

package/lib/rules/prefer-hooks-in-order.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+const HooksOrder = ['beforeAll', 'beforeEach', 'afterEach', 'afterAll'];
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer having hooks in a consistent order'
+    },
+    messages: {
+      reorderHooks: `\`{{ currentHook }}\` hooks should be before any \`{{ previousHook }}\` hooks`
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    let previousHookIndex = -1;
+    let inHook = false;
+    return {
+      CallExpression(node) {
+        if (inHook) {
+          // Ignore everything that is passed into a hook
+          return;
+        }
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'hook') {
+          // Reset the previousHookIndex when encountering something different from a hook
+          previousHookIndex = -1;
+          return;
+        }
+        inHook = true;
+        const currentHook = jestFnCall.name;
+        const currentHookIndex = HooksOrder.indexOf(currentHook);
+        if (currentHookIndex < previousHookIndex) {
+          context.report({
+            messageId: 'reorderHooks',
+            node,
+            data: {
+              previousHook: HooksOrder[previousHookIndex],
+              currentHook
+            }
+          });
+          return;
+        }
+        previousHookIndex = currentHookIndex;
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['hook'])) {
+          inHook = false;
+          return;
+        }
+        if (inHook) {
+          return;
+        }
+
+        // Reset the previousHookIndex when encountering something different from a hook
+        previousHookIndex = -1;
+      }
+    };
+  }
+});

package/lib/rules/prefer-hooks-on-top.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest having hooks before any test cases'
+    },
+    messages: {
+      noHookOnTop: 'Hooks should come before test cases'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    const hooksContext = [false];
+    return {
+      CallExpression(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['test'])) {
+          hooksContext[hooksContext.length - 1] = true;
+        }
+        if (hooksContext[hooksContext.length - 1] && (0, _utils.isTypeOfJestFnCall)(node, context, ['hook'])) {
+          context.report({
+            messageId: 'noHookOnTop',
+            node
+          });
+        }
+        hooksContext.push(false);
+      },
+      'CallExpression:exit'() {
+        hooksContext.pop();
+      }
+    };
+  }
+});