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

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

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const findNodeObject = node => {
+  if ('object' in node) {
+    return node.object;
+  }
+  if (node.callee.type === _utils.AST_NODE_TYPES.MemberExpression) {
+    return node.callee.object;
+  }
+  return null;
+};
+const getJestFnCall = node => {
+  if (node.type !== _utils.AST_NODE_TYPES.CallExpression && node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+    return null;
+  }
+  const obj = findNodeObject(node);
+  if (!obj) {
+    return null;
+  }
+  if (obj.type === _utils.AST_NODE_TYPES.Identifier) {
+    return node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.getNodeName)(node.callee) === 'jest.fn' ? node : null;
+  }
+  return getJestFnCall(obj);
+};
+const getAutoFixMockImplementation = (jestFnCall, context) => {
+  const hasMockImplementationAlready = jestFnCall.parent.type === _utils.AST_NODE_TYPES.MemberExpression && jestFnCall.parent.property.type === _utils.AST_NODE_TYPES.Identifier && jestFnCall.parent.property.name === 'mockImplementation';
+  if (hasMockImplementationAlready) {
+    return '';
+  }
+  const [arg] = jestFnCall.arguments;
+  const argSource = arg && context.sourceCode.getText(arg);
+  return argSource ? `.mockImplementation(${argSource})` : '.mockImplementation()';
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest using `jest.spyOn()`'
+    },
+    messages: {
+      useJestSpyOn: 'Use jest.spyOn() instead'
+    },
+    fixable: 'code',
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      AssignmentExpression(node) {
+        const {
+          left,
+          right
+        } = node;
+        if (left.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        const jestFnCall = getJestFnCall(right);
+        if (!jestFnCall) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: 'useJestSpyOn',
+          fix(fixer) {
+            const leftPropQuote = left.property.type === _utils.AST_NODE_TYPES.Identifier && !left.computed ? "'" : '';
+            const mockImplementation = getAutoFixMockImplementation(jestFnCall, context);
+            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

@@ -0,0 +1,46 @@
+"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 using `toStrictEqual()`'
+    },
+    messages: {
+      useToStrictEqual: 'Use `toStrictEqual()` instead',
+      suggestReplaceWithStrictEqual: 'Replace with `toStrictEqual()`'
+    },
+    type: 'suggestion',
+    schema: [],
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          matcher
+        } = jestFnCall;
+        if ((0, _utils.isSupportedAccessor)(matcher, 'toEqual')) {
+          context.report({
+            messageId: 'useToStrictEqual',
+            node: matcher,
+            suggest: [{
+              messageId: 'suggestReplaceWithStrictEqual',
+              fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher, _utils.EqualityMatcher.toStrictEqual)]
+            }]
+          });
+        }
+      }
+    };
+  }
+});

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

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const isNullLiteral = node => node.type === _utils.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 = expectFnCall => isNullLiteral((0, _utils2.getFirstMatcherArg)(expectFnCall));
+const isFirstArgumentIdentifier = (expectFnCall, name) => (0, _utils2.isIdentifier)((0, _utils2.getFirstMatcherArg)(expectFnCall), name);
+const shouldUseToBe = expectFnCall => {
+  let firstArg = (0, _utils2.getFirstMatcherArg)(expectFnCall);
+  if (firstArg.type === _utils.AST_NODE_TYPES.UnaryExpression && firstArg.operator === '-') {
+    firstArg = firstArg.argument;
+  }
+  if (firstArg.type === _utils.AST_NODE_TYPES.Literal) {
+    // regex literals are classed as literals, but they're actually objects
+    // which means "toBe" will give different results than other matchers
+    return !('regex' in firstArg);
+  }
+  return firstArg.type === _utils.AST_NODE_TYPES.TemplateLiteral;
+};
+const reportPreferToBe = (context, whatToBe, expectFnCall, func, modifierNode) => {
+  context.report({
+    messageId: `useToBe${whatToBe}`,
+    fix(fixer) {
+      const fixes = [(0, _utils2.replaceAccessorFixer)(fixer, expectFnCall.matcher, `toBe${whatToBe}`)];
+      if (expectFnCall.args.length && whatToBe !== '') {
+        fixes.push((0, _utils2.removeExtraArgumentsFixer)(fixer, context, func, 0));
+      }
+      if (modifierNode) {
+        fixes.push(fixer.removeRange([modifierNode.range[0] - 1, modifierNode.range[1]]));
+      }
+      return fixes;
+    },
+    node: expectFnCall.matcher
+  });
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest using `toBe()` for primitive literals'
+    },
+    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) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const matcherName = (0, _utils2.getAccessorValue)(jestFnCall.matcher);
+        const notModifier = jestFnCall.modifiers.find(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+        if (notModifier && ['toBeUndefined', 'toBeDefined'].includes(matcherName)) {
+          reportPreferToBe(context, matcherName === 'toBeDefined' ? 'Undefined' : 'Defined', jestFnCall, node, notModifier);
+          return;
+        }
+        if (!_utils2.EqualityMatcher.hasOwnProperty(matcherName) || jestFnCall.args.length === 0) {
+          return;
+        }
+        if (isNullEqualityMatcher(jestFnCall)) {
+          reportPreferToBe(context, 'Null', jestFnCall, node);
+          return;
+        }
+        if (isFirstArgumentIdentifier(jestFnCall, 'undefined')) {
+          const name = notModifier ? 'Defined' : 'Undefined';
+          reportPreferToBe(context, name, jestFnCall, node, notModifier);
+          return;
+        }
+        if (isFirstArgumentIdentifier(jestFnCall, 'NaN')) {
+          reportPreferToBe(context, 'NaN', jestFnCall, node);
+          return;
+        }
+        if (shouldUseToBe(jestFnCall) && matcherName !== _utils2.EqualityMatcher.toBe) {
+          reportPreferToBe(context, '', jestFnCall, node);
+        }
+      }
+    };
+  }
+});

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

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+/**
+ * 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}
+ */
+const isFixableIncludesCallExpression = node => node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'includes') && (0, _utils2.hasOnlyOneArgument)(node) && node.arguments[0].type !== _utils.AST_NODE_TYPES.SpreadElement;
+
+// expect(array.includes(<value>)[not.]{toBe,toEqual}(<boolean>)
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest using `toContain()`'
+    },
+    messages: {
+      useToContain: 'Use toContain() instead'
+    },
+    fixable: 'code',
+    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: [includesCall],
+          range: [, expectCallEnd]
+        } = expect;
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
+        if (!includesCall || matcherArg.type === _utils.AST_NODE_TYPES.SpreadElement || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg) || !isFixableIncludesCallExpression(includesCall)) {
+          return;
+        }
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+        context.report({
+          fix(fixer) {
+            const {
+              sourceCode
+            } = context;
+
+            // we need to negate the expectation if the current expected
+            // value is itself negated by the "not" modifier
+            const addNotModifier = matcherArg.value === hasNot;
+            return [
+            // remove the "includes" call entirely
+            fixer.removeRange([includesCall.callee.property.range[0] - 1, includesCall.range[1]]),
+            // replace the current matcher with "toContain", adding "not" if needed
+            fixer.replaceTextRange([expectCallEnd, matcher.parent.range[1]], addNotModifier ? `.${_utils2.ModifierName.not}.toContain` : '.toContain'),
+            // replace the matcher argument with the value from the "includes"
+            fixer.replaceText(jestFnCall.args[0], sourceCode.getText(includesCall.arguments[0]))];
+          },
+          messageId: 'useToContain',
+          node: matcher
+        });
+      }
+    };
+  }
+});

package/lib/rules/prefer-to-have-been-called-times.js

@@ -0,0 +1,70 @@
+"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: {
+    fixable: 'code',
+    docs: {
+      description: 'Suggest using `toHaveBeenCalledTimes()`'
+    },
+    messages: {
+      preferMatcher: 'Prefer `toHaveBeenCalledTimes`'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          parent: expect
+        } = jestFnCall.head.node;
+        if (expect.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+        const {
+          matcher
+        } = jestFnCall;
+        if (!(0, _utils2.isSupportedAccessor)(matcher, 'toHaveLength')) {
+          return;
+        }
+        const [argument] = expect.arguments;
+
+        // check if the last property in the chain is `calls`
+        if (argument.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(argument.property, 'calls')) {
+          return;
+        }
+        const {
+          object
+        } = argument;
+
+        // check if the second-to-last property in the chain is `mock`
+        if (object.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(object.property, 'mock')) {
+          return;
+        }
+        context.report({
+          messageId: 'preferMatcher',
+          node: matcher,
+          fix(fixer) {
+            return [
+            // remove the "mock.calls" accessor chain
+            fixer.removeRange([object.property.range[0] - 1, argument.range[1]]),
+            // replace the current matcher with "toHaveBeenCalledTimes"
+            fixer.replaceTextRange([matcher.parent.object.range[1], matcher.parent.range[1]], '.toHaveBeenCalledTimes')];
+          }
+        });
+      }
+    };
+  }
+});

package/lib/rules/prefer-to-have-been-called.js

@@ -0,0 +1,59 @@
+"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 `toHaveBeenCalled`'
+    },
+    messages: {
+      preferMatcher: 'Use `toHaveBeenCalled`'
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          matcher
+        } = jestFnCall;
+        if (!['toBeCalledTimes', 'toHaveBeenCalledTimes'].includes((0, _utils2.getAccessorValue)(matcher))) {
+          return;
+        }
+        const arg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
+        if (arg.type !== _utils.AST_NODE_TYPES.Literal || arg.value !== 0) {
+          return;
+        }
+        const notModifier = jestFnCall.modifiers.find(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+        context.report({
+          messageId: 'preferMatcher',
+          node: matcher,
+          fix(fixer) {
+            let replacementMatcher = '.not.toHaveBeenCalled';
+            if (notModifier) {
+              replacementMatcher = '.toHaveBeenCalled';
+            }
+            return [
+            // remove all the arguments to the matcher
+            fixer.removeRange([jestFnCall.args[0].range[0], jestFnCall.args[jestFnCall.args.length - 1].range[1]]),
+            // replace the current matcher with "(.not).toHaveBeenCalled"
+            fixer.replaceTextRange([(notModifier || matcher).parent.object.range[1], jestFnCall.matcher.parent.range[1]], replacementMatcher)];
+          }
+        });
+      }
+    };
+  }
+});

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

@@ -0,0 +1,57 @@
+"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 `toHaveLength()`'
+    },
+    messages: {
+      useToHaveLength: 'Use toHaveLength() instead'
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          parent: expect
+        } = jestFnCall.head.node;
+        if (expect.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+        const [argument] = expect.arguments;
+        const {
+          matcher
+        } = jestFnCall;
+        if (!_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || argument.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(argument.property, 'length')) {
+          return;
+        }
+        context.report({
+          fix(fixer) {
+            return [
+            // remove the "length" property accessor
+            fixer.removeRange([argument.property.range[0] - 1, argument.range[1]]),
+            // replace the current matcher with "toHaveLength"
+            fixer.replaceTextRange([matcher.parent.object.range[1], matcher.parent.range[1]], '.toHaveLength')];
+          },
+          messageId: 'useToHaveLength',
+          node: matcher
+        });
+      }
+    };
+  }
+});

package/lib/rules/prefer-todo.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+function isEmptyFunction(node) {
+  if (!(0, _utils2.isFunction)(node)) {
+    return false;
+  }
+  return node.body.type === _utils.AST_NODE_TYPES.BlockStatement && !node.body.body.length;
+}
+function createTodoFixer(jestFnCall, fixer) {
+  if (jestFnCall.members.length) {
+    return (0, _utils2.replaceAccessorFixer)(fixer, jestFnCall.members[0], 'todo');
+  }
+  return fixer.replaceText(jestFnCall.head.node, `${jestFnCall.head.local}.todo`);
+}
+const isTargetedTestCase = jestFnCall => {
+  if (jestFnCall.members.some(s => (0, _utils2.getAccessorValue)(s) !== 'skip')) {
+    return false;
+  }
+
+  // todo: we should support this too (needs custom fixer)
+  if (jestFnCall.name.startsWith('x')) {
+    return false;
+  }
+  return !jestFnCall.name.startsWith('f');
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest using `test.todo`'
+    },
+    messages: {
+      emptyTest: 'Prefer todo test case over empty test case',
+      unimplementedTest: 'Prefer todo test case over unimplemented test case'
+    },
+    fixable: 'code',
+    schema: [],
+    type: 'layout'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const [title, callback] = node.arguments;
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (!title || jestFnCall?.type !== 'test' || !isTargetedTestCase(jestFnCall) || !(0, _utils2.isStringNode)(title)) {
+          return;
+        }
+        if (callback && isEmptyFunction(callback)) {
+          context.report({
+            messageId: 'emptyTest',
+            node,
+            fix: fixer => [fixer.removeRange([title.range[1], callback.range[1]]), createTodoFixer(jestFnCall, fixer)]
+          });
+        }
+        if ((0, _utils2.hasOnlyOneArgument)(node)) {
+          context.report({
+            messageId: 'unimplementedTest',
+            node,
+            fix: fixer => createTodoFixer(jestFnCall, fixer)
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/require-hook.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const isJestFnCall = (node, context) => {
+  if ((0, _utils2.parseJestFnCall)(node, context)) {
+    return true;
+  }
+  return !!(0, _utils2.getNodeName)(node)?.startsWith('jest.');
+};
+const isNullOrUndefined = node => {
+  return node.type === _utils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils2.isIdentifier)(node, 'undefined');
+};
+const shouldBeInHook = (node, context, allowedFunctionCalls = []) => {
+  switch (node.type) {
+    case _utils.AST_NODE_TYPES.ExpressionStatement:
+      return shouldBeInHook(node.expression, context, allowedFunctionCalls);
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return !(isJestFnCall(node, context) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
+    case _utils.AST_NODE_TYPES.VariableDeclaration:
+      {
+        if (node.kind === 'const') {
+          return false;
+        }
+        return node.declarations.some(({
+          init
+        }) => init !== null && !isNullOrUndefined(init));
+      }
+    default:
+      return false;
+  }
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Require setup and teardown code to be within a hook'
+    },
+    messages: {
+      useHook: 'This should be done within a hook'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        allowedFunctionCalls: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    allowedFunctionCalls: []
+  }],
+  create(context) {
+    const {
+      allowedFunctionCalls
+    } = context.options[0] ?? {};
+    const checkBlockBody = body => {
+      for (const statement of body) {
+        if (shouldBeInHook(statement, context, allowedFunctionCalls)) {
+          context.report({
+            node: statement,
+            messageId: 'useHook'
+          });
+        }
+      }
+    };
+    return {
+      Program(program) {
+        checkBlockBody(program.body);
+      },
+      CallExpression(node) {
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['describe']) || node.arguments.length < 2) {
+          return;
+        }
+        const [, testFn] = node.arguments;
+        if (!(0, _utils2.isFunction)(testFn) || testFn.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+          return;
+        }
+        checkBlockBody(testFn.body.body);
+      }
+    };
+  }
+});