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

package/lib/rules/no-unnecessary-assertion.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");
+const canBe = (firstArgumentType, flag) => {
+  if (firstArgumentType.isUnion()) {
+    return firstArgumentType.types.some(typ => typ.flags & flag);
+  }
+  return firstArgumentType.flags & flag;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow unnecessary assertions based on types',
+      requiresTypeChecking: true
+    },
+    messages: {
+      unnecessaryAssertion: 'Unnecessary assertion, subject cannot be {{ thing }}',
+      noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = _utils.ESLintUtils.getParserServices(context);
+    const compilerOptions = services.program.getCompilerOptions();
+    const isStrictNullChecks = compilerOptions.strictNullChecks || compilerOptions.strict && compilerOptions.strictNullChecks !== false;
+    if (!isStrictNullChecks) {
+      context.report({
+        loc: {
+          start: {
+            column: 0,
+            line: 0
+          },
+          end: {
+            column: 0,
+            line: 0
+          }
+        },
+        messageId: 'noStrictNullCheck'
+      });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const {
+      TypeFlags
+    } = require('typescript');
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect' || jestFnCall.head.node.parent.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+        const matcherName = (0, _utils2.getAccessorValue)(jestFnCall.matcher);
+        if (!['toBeNull', 'toBeDefined', 'toBeUndefined', 'toBeNaN'].includes(matcherName)) {
+          return;
+        }
+
+        // todo: we should support resolving promise types
+        if (jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) !== 'not')) {
+          return;
+        }
+        const [argument] = jestFnCall.head.node.parent.arguments;
+        let desiredType = TypeFlags.Any | TypeFlags.Unknown;
+
+        // add in the appropriate type flag based on the matcher being used
+        desiredType |= matcherName === 'toBeNaN' ? TypeFlags.NumberLike : matcherName === 'toBeNull' ? TypeFlags.Null : TypeFlags.Undefined;
+        if (canBe(services.getTypeAtLocation(argument), desiredType)) {
+          return;
+        }
+        context.report({
+          messageId: 'unnecessaryAssertion',
+          data: {
+            thing: matcherName === 'toBeNaN' ? 'a number' : matcherName === 'toBeNull' ? 'null' : 'undefined'
+          },
+          node
+        });
+      }
+    };
+  }
+});

package/lib/rules/no-unneeded-async-expect-function.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: 'Disallow unnecessary async function wrapper for expected promises'
+    },
+    fixable: 'code',
+    messages: {
+      noAsyncWrapperForExpectedPromise: 'Unnecessary async function wrapper'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      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 || !(0, _utils2.isFunction)(awaitNode) || !awaitNode.async || awaitNode.body.type !== _utils.AST_NODE_TYPES.BlockStatement || awaitNode.body.body.length !== 1) {
+          return;
+        }
+        const [callback] = awaitNode.body.body;
+        if (callback.type === _utils.AST_NODE_TYPES.ExpressionStatement && callback.expression.type === _utils.AST_NODE_TYPES.AwaitExpression && callback.expression.argument.type === _utils.AST_NODE_TYPES.CallExpression) {
+          const innerAsyncFuncCall = callback.expression.argument;
+          context.report({
+            node: awaitNode,
+            messageId: 'noAsyncWrapperForExpectedPromise',
+            fix(fixer) {
+              const {
+                sourceCode
+              } = context;
+              return [fixer.replaceTextRange([awaitNode.range[0], awaitNode.range[1]], sourceCode.getText(innerAsyncFuncCall))];
+            }
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-untyped-mock-factory.js

@@ -0,0 +1,61 @@
+"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: 'Disallow using `jest.mock()` factories without an explicit type parameter'
+    },
+    messages: {
+      addTypeParameterToModuleMock: 'Add a type parameter to the mock factory such as `typeof import({{ moduleName }})`'
+    },
+    fixable: 'code',
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const {
+          callee,
+          typeArguments
+        } = node;
+        if (callee.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        const {
+          property
+        } = callee;
+        if (node.arguments.length === 2 && (0, _utils2.isTypeOfJestFnCall)(node, context, ['jest']) && (0, _utils2.isSupportedAccessor)(property) && ['mock', 'doMock'].includes((0, _utils2.getAccessorValue)(property))) {
+          const [nameNode, factoryNode] = node.arguments;
+          const hasTypeParameter = typeArguments !== undefined && typeArguments.params.length > 0;
+          const hasReturnType = (0, _utils2.isFunction)(factoryNode) && factoryNode.returnType !== undefined;
+          if (hasTypeParameter || hasReturnType) {
+            return;
+          }
+          const moduleName = (0, _utils2.findModuleName)(nameNode);
+          context.report({
+            messageId: 'addTypeParameterToModuleMock',
+            data: {
+              moduleName: moduleName?.raw ?? './module-name'
+            },
+            node,
+            fix(fixer) {
+              if (!moduleName) {
+                return [];
+              }
+              return [fixer.insertTextAfter(callee, `<typeof import(${moduleName.raw})>`)];
+            }
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/padding-around-after-all-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.AfterAllToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.AfterAllToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `afterAll` blocks', config);

package/lib/rules/padding-around-after-each-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.AfterEachToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.AfterEachToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `afterEach` blocks', config);

package/lib/rules/padding-around-all.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _paddingAroundAfterAllBlocks = require("./padding-around-after-all-blocks");
+var _paddingAroundAfterEachBlocks = require("./padding-around-after-each-blocks");
+var _paddingAroundBeforeAllBlocks = require("./padding-around-before-all-blocks");
+var _paddingAroundBeforeEachBlocks = require("./padding-around-before-each-blocks");
+var _paddingAroundDescribeBlocks = require("./padding-around-describe-blocks");
+var _paddingAroundExpectGroups = require("./padding-around-expect-groups");
+var _paddingAroundTestBlocks = require("./padding-around-test-blocks");
+var _padding = require("./utils/padding");
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around Jest functions', [..._paddingAroundAfterAllBlocks.config, ..._paddingAroundAfterEachBlocks.config, ..._paddingAroundBeforeAllBlocks.config, ..._paddingAroundBeforeEachBlocks.config, ..._paddingAroundDescribeBlocks.config, ..._paddingAroundExpectGroups.config, ..._paddingAroundTestBlocks.config]);

package/lib/rules/padding-around-before-all-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.BeforeAllToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.BeforeAllToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `beforeAll` blocks', config);

package/lib/rules/padding-around-before-each-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.BeforeEachToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.BeforeEachToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `beforeEach` blocks', config);

package/lib/rules/padding-around-describe-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: [_padding.StatementType.DescribeToken, _padding.StatementType.FdescribeToken, _padding.StatementType.XdescribeToken]
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: [_padding.StatementType.DescribeToken, _padding.StatementType.FdescribeToken, _padding.StatementType.XdescribeToken],
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `describe` blocks', config);

package/lib/rules/padding-around-expect-groups.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.ExpectToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.ExpectToken,
+  nextStatementType: _padding.StatementType.Any
+}, {
+  paddingType: _padding.PaddingType.Any,
+  prevStatementType: _padding.StatementType.ExpectToken,
+  nextStatementType: _padding.StatementType.ExpectToken
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `expect` groups', config);

package/lib/rules/padding-around-test-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: [_padding.StatementType.TestToken, _padding.StatementType.ItToken, _padding.StatementType.FitToken, _padding.StatementType.XitToken, _padding.StatementType.XtestToken]
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: [_padding.StatementType.TestToken, _padding.StatementType.ItToken, _padding.StatementType.FitToken, _padding.StatementType.XitToken, _padding.StatementType.XtestToken],
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `test` and `it` blocks', config);

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

@@ -0,0 +1,47 @@
+"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 `toHaveBeenCalledWith()`'
+    },
+    messages: {
+      preferCalledWith: 'Prefer {{ matcherName }}With(/* expected args */)'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        if (jestFnCall.modifiers.some(nod => (0, _utils.getAccessorValue)(nod) === 'not')) {
+          return;
+        }
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherName = (0, _utils.getAccessorValue)(matcher);
+        if (['toBeCalled', 'toHaveBeenCalled'].includes(matcherName)) {
+          context.report({
+            data: {
+              matcherName
+            },
+            messageId: 'preferCalledWith',
+            node: matcher
+          });
+        }
+      }
+    };
+  }
+});

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

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const isString = node => {
+  return (0, _utils2.isStringNode)(node) || node.type === _utils.AST_NODE_TYPES.TemplateLiteral;
+};
+const isComparingToString = expression => {
+  return isString(expression.left) || isString(expression.right);
+};
+const invertOperator = operator => {
+  switch (operator) {
+    case '>':
+      return '<=';
+    case '<':
+      return '>=';
+    case '>=':
+      return '<';
+    case '<=':
+      return '>';
+  }
+  return null;
+};
+const determineMatcher = (operator, negated) => {
+  const op = negated ? invertOperator(operator) : operator;
+  switch (op) {
+    case '>':
+      return 'toBeGreaterThan';
+    case '<':
+      return 'toBeLessThan';
+    case '>=':
+      return 'toBeGreaterThanOrEqual';
+    case '<=':
+      return 'toBeLessThanOrEqual';
+  }
+  return null;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Suggest using the built-in comparison matchers'
+    },
+    messages: {
+      useToBeComparison: 'Prefer using `{{ preferredMatcher }}` 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: [comparison],
+          range: [, expectCallEnd]
+        } = expect;
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
+        if (comparison.type !== _utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg)) {
+          return;
+        }
+        const [modifier] = jestFnCall.modifiers;
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+        const preferredMatcher = determineMatcher(comparison.operator, matcherArg.value === hasNot);
+        if (!preferredMatcher) {
+          return;
+        }
+        context.report({
+          fix(fixer) {
+            const {
+              sourceCode
+            } = context;
+
+            // preserve the existing modifier if it's not a negation
+            const modifierText = modifier && (0, _utils2.getAccessorValue)(modifier) !== 'not' ? `.${(0, _utils2.getAccessorValue)(modifier)}` : '';
+            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}.${preferredMatcher}`),
+            // replace the matcher argument with the right-hand side of the comparison
+            fixer.replaceText(matcherArg, sourceCode.getText(comparison.right))];
+          },
+          messageId: 'useToBeComparison',
+          data: {
+            preferredMatcher
+          },
+          node: matcher
+        });
+      }
+    };
+  }
+});

package/lib/rules/prefer-each.js

@@ -0,0 +1,77 @@
+"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: 'Prefer using `.each` rather than manual loops'
+    },
+    messages: {
+      preferEach: 'prefer using `{{ fn }}.each` rather than a manual loop'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const jestFnCalls = [];
+    let inTestCaseCall = false;
+    const recommendFn = () => {
+      if (jestFnCalls.length === 1 && jestFnCalls[0] === 'test') {
+        return 'it';
+      }
+      return 'describe';
+    };
+    const enterForLoop = () => {
+      if (jestFnCalls.length === 0 || inTestCaseCall) {
+        return;
+      }
+      jestFnCalls.length = 0;
+    };
+    const exitForLoop = node => {
+      if (jestFnCalls.length === 0 || inTestCaseCall) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: 'preferEach',
+        data: {
+          fn: recommendFn()
+        }
+      });
+      jestFnCalls.length = 0;
+    };
+    return {
+      ForStatement: enterForLoop,
+      'ForStatement:exit': exitForLoop,
+      ForInStatement: enterForLoop,
+      'ForInStatement:exit': exitForLoop,
+      ForOfStatement: enterForLoop,
+      'ForOfStatement:exit': exitForLoop,
+      CallExpression(node) {
+        const {
+          type: jestFnCallType
+        } = (0, _utils.parseJestFnCall)(node, context) ?? {};
+        if (jestFnCallType === 'hook' || jestFnCallType === 'describe' || jestFnCallType === 'test') {
+          jestFnCalls.push(jestFnCallType);
+        }
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = true;
+        }
+      },
+      'CallExpression:exit'(node) {
+        const {
+          type: jestFnCallType
+        } = (0, _utils.parseJestFnCall)(node, context) ?? {};
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = false;
+        }
+      }
+    };
+  }
+});