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

package/lib/rules/prefer-importing-jest-globals.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const createFixerImports = (isModule, functionsToImport) => {
+  const allImportsFormatted = Array.from(functionsToImport).sort().join(', ');
+  return isModule ? `import { ${allImportsFormatted} } from '@jest/globals';` : `const { ${allImportsFormatted} } = require('@jest/globals');`;
+};
+const allJestFnTypes = ['hook', 'describe', 'test', 'expect', 'jest', 'unknown'];
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer importing Jest globals'
+    },
+    messages: {
+      preferImportingJestGlobal: `Import the following Jest functions from '@jest/globals': {{ jestFunctions }}`
+    },
+    fixable: 'code',
+    type: 'problem',
+    schema: [{
+      type: 'object',
+      properties: {
+        types: {
+          type: 'array',
+          items: {
+            type: 'string',
+            enum: allJestFnTypes
+          }
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    types: allJestFnTypes
+  }],
+  create(context) {
+    const {
+      types = allJestFnTypes
+    } = context.options[0] || {};
+    const functionsToImport = new Set();
+    let reportingNode;
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (!jestFnCall) {
+          return;
+        }
+        if (jestFnCall.head.type !== 'import' && types.includes(jestFnCall.type)) {
+          functionsToImport.add(jestFnCall.name);
+          reportingNode ||= jestFnCall.head.node;
+        }
+      },
+      'Program:exit'() {
+        // this means we found at least one function to import
+        if (!reportingNode) {
+          return;
+        }
+        const isModule = context.parserOptions?.sourceType === 'module' || context.languageOptions.sourceType === 'module';
+        context.report({
+          node: reportingNode,
+          messageId: 'preferImportingJestGlobal',
+          data: {
+            jestFunctions: Array.from(functionsToImport).join(', ')
+          },
+          fix(fixer) {
+            const {
+              sourceCode
+            } = context;
+            const [firstNode] = sourceCode.ast.body;
+
+            // check if "use strict" directive exists
+            if (firstNode.type === _utils.AST_NODE_TYPES.ExpressionStatement && (0, _utils2.isStringNode)(firstNode.expression, 'use strict')) {
+              return fixer.insertTextAfter(firstNode, `\n${createFixerImports(isModule, functionsToImport)}`);
+            }
+            const importNode = sourceCode.ast.body.find(node => node.type === _utils.AST_NODE_TYPES.ImportDeclaration && node.source.value === '@jest/globals');
+            if (importNode?.type === _utils.AST_NODE_TYPES.ImportDeclaration) {
+              for (const specifier of importNode.specifiers) {
+                if (specifier.type === _utils.AST_NODE_TYPES.ImportSpecifier) {
+                  let importName = 'name' in specifier.imported ? specifier.imported.name : '';
+                  const local = (0, _utils2.getAccessorValue)(specifier.local);
+                  if (local !== importName) {
+                    importName = `${importName} as ${local}`;
+                  }
+                  if ('value' in specifier.imported) {
+                    importName = `'${specifier.imported.value}'${importName}`;
+                  }
+                  functionsToImport.add(importName);
+                }
+                if (specifier.type === _utils.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                  functionsToImport.add(specifier.local.name);
+                }
+              }
+              return fixer.replaceText(importNode, createFixerImports(isModule, functionsToImport));
+            }
+            const requireNode = sourceCode.ast.body.find(node => node.type === _utils.AST_NODE_TYPES.VariableDeclaration && node.declarations.some(declaration => declaration.init?.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isIdentifier)(declaration.init.callee, 'require') && (0, _utils2.isStringNode)(declaration.init.arguments[0], '@jest/globals') && (declaration.id.type === _utils.AST_NODE_TYPES.Identifier || declaration.id.type === _utils.AST_NODE_TYPES.ObjectPattern)));
+            if (requireNode?.type !== _utils.AST_NODE_TYPES.VariableDeclaration) {
+              return fixer.insertTextBefore(firstNode, `${createFixerImports(isModule, functionsToImport)}\n`);
+            }
+            if (requireNode.declarations[0]?.id.type === _utils.AST_NODE_TYPES.ObjectPattern) {
+              for (const property of requireNode.declarations[0].id.properties) {
+                if (property.type !== _utils.AST_NODE_TYPES.Property || !(0, _utils2.isSupportedAccessor)(property.key)) {
+                  continue;
+                }
+                let importName = (0, _utils2.getAccessorValue)(property.key);
+                if ((0, _utils2.isSupportedAccessor)(property.value)) {
+                  const local = (0, _utils2.getAccessorValue)(property.value);
+                  if (importName !== local) {
+                    importName += `: ${local}`;
+                  }
+                }
+                functionsToImport.add(importName);
+              }
+            }
+            return fixer.replaceText(requireNode, `${createFixerImports(isModule, functionsToImport)}`);
+          }
+        });
+      }
+    };
+  }
+});

package/lib/rules/prefer-jest-mocked.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const mockTypes = ['Mock', 'MockedFunction', 'MockedClass', 'MockedObject'];
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer `jest.mocked()` over `fn as jest.Mock`'
+    },
+    messages: {
+      useJestMocked: 'Prefer `jest.mocked()`'
+    },
+    schema: [],
+    type: 'suggestion',
+    fixable: 'code'
+  },
+  defaultOptions: [],
+  create(context) {
+    function check(node) {
+      const {
+        typeAnnotation
+      } = node;
+      if (typeAnnotation.type !== _utils.AST_NODE_TYPES.TSTypeReference) {
+        return;
+      }
+      const {
+        typeName
+      } = typeAnnotation;
+      if (typeName.type !== _utils.AST_NODE_TYPES.TSQualifiedName) {
+        return;
+      }
+      const {
+        left,
+        right
+      } = typeName;
+      if (left.type !== _utils.AST_NODE_TYPES.Identifier || right.type !== _utils.AST_NODE_TYPES.Identifier || left.name !== 'jest' || !mockTypes.includes(right.name)) {
+        return;
+      }
+      const fnName = context.sourceCode.text.slice(...(0, _utils2.followTypeAssertionChain)(node.expression).range);
+      context.report({
+        node,
+        messageId: 'useJestMocked',
+        fix(fixer) {
+          return fixer.replaceText(node, `jest.mocked(${fnName})`);
+        }
+      });
+    }
+    return {
+      TSAsExpression(node) {
+        if (node.parent.type === _utils.AST_NODE_TYPES.TSAsExpression) {
+          return;
+        }
+        check(node);
+      },
+      TSTypeAssertion(node) {
+        check(node);
+      }
+    };
+  }
+});

package/lib/rules/prefer-lowercase-title.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+const hasStringAsFirstArgument = node => node.arguments[0] && (0, _utils.isStringNode)(node.arguments[0]);
+const populateIgnores = ignore => {
+  const ignores = [];
+  if (ignore.includes(_utils.DescribeAlias.describe)) {
+    ignores.push(...Object.keys(_utils.DescribeAlias));
+  }
+  if (ignore.includes(_utils.TestCaseName.test)) {
+    ignores.push(...Object.keys(_utils.TestCaseName).filter(k => k.endsWith(_utils.TestCaseName.test)));
+  }
+  if (ignore.includes(_utils.TestCaseName.it)) {
+    ignores.push(...Object.keys(_utils.TestCaseName).filter(k => k.endsWith(_utils.TestCaseName.it)));
+  }
+  return ignores;
+};
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce lowercase test names'
+    },
+    fixable: 'code',
+    messages: {
+      unexpectedCase: '`{{ method }}`s should begin with lowercase'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        ignore: {
+          type: 'array',
+          items: {
+            type: 'string',
+            // for some reason TypeScript thinks this _must_ be a read-only
+            // array, so we have to explicitly cast it as a mutable array
+            enum: [_utils.DescribeAlias.describe, _utils.TestCaseName.test, _utils.TestCaseName.it]
+          },
+          additionalItems: false
+        },
+        allowedPrefixes: {
+          type: 'array',
+          items: {
+            type: 'string'
+          },
+          additionalItems: false
+        },
+        ignoreTopLevelDescribe: {
+          type: 'boolean',
+          default: false
+        },
+        ignoreTodos: {
+          type: 'boolean',
+          default: false
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    ignore: [],
+    allowedPrefixes: [],
+    ignoreTopLevelDescribe: false,
+    ignoreTodos: false
+  }],
+  create(context, [{
+    ignore = [],
+    allowedPrefixes = [],
+    ignoreTopLevelDescribe,
+    ignoreTodos
+  }]) {
+    const ignores = populateIgnores(ignore);
+    let numberOfDescribeBlocks = 0;
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (!jestFnCall || !hasStringAsFirstArgument(node)) {
+          return;
+        }
+        if (jestFnCall.type === 'describe') {
+          numberOfDescribeBlocks++;
+          if (ignoreTopLevelDescribe && numberOfDescribeBlocks === 1) {
+            return;
+          }
+        } else if (jestFnCall.type !== 'test') {
+          return;
+        }
+
+        // Ignore *.todo test and/or test suites
+        if (ignoreTodos && jestFnCall.members.some(s => (0, _utils.getAccessorValue)(s) === 'todo')) {
+          return;
+        }
+        const [firstArg] = node.arguments;
+        const description = (0, _utils.getStringValue)(firstArg);
+        if (allowedPrefixes.some(name => description.startsWith(name))) {
+          return;
+        }
+        const firstCharacter = description.charAt(0);
+        if (!firstCharacter || firstCharacter === firstCharacter.toLowerCase() || ignores.includes(jestFnCall.name)) {
+          return;
+        }
+        context.report({
+          messageId: 'unexpectedCase',
+          node: node.arguments[0],
+          data: {
+            method: jestFnCall.name
+          },
+          fix(fixer) {
+            const description = (0, _utils.getStringValue)(firstArg);
+            const rangeIgnoringQuotes = [firstArg.range[0] + 1, firstArg.range[1] - 1];
+            const newDescription = description.substring(0, 1).toLowerCase() + description.substring(1);
+            return [fixer.replaceTextRange(rangeIgnoringQuotes, newDescription)];
+          }
+        });
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe'])) {
+          numberOfDescribeBlocks--;
+        }
+      }
+    };
+  }
+});

package/lib/rules/prefer-mock-promise-shorthand.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const withOnce = (name, addOnce) => {
+  return `${name}${addOnce ? 'Once' : ''}`;
+};
+const findSingleReturnArgumentNode = fnNode => {
+  if (fnNode.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+    return fnNode.body;
+  }
+  if (fnNode.body.body[0]?.type === _utils.AST_NODE_TYPES.ReturnStatement) {
+    return fnNode.body.body[0].argument;
+  }
+  return null;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer mock resolved/rejected shorthands for promises'
+    },
+    messages: {
+      useMockShorthand: 'Prefer {{ replacement }}'
+    },
+    schema: [],
+    type: 'suggestion',
+    fixable: 'code'
+  },
+  defaultOptions: [],
+  create(context) {
+    const report = (property, isOnce, outerArgNode, innerArgNode = outerArgNode) => {
+      if (innerArgNode?.type !== _utils.AST_NODE_TYPES.CallExpression) {
+        return;
+      }
+      const argName = (0, _utils2.getNodeName)(innerArgNode);
+      if (argName !== 'Promise.resolve' && argName !== 'Promise.reject') {
+        return;
+      }
+      const replacement = withOnce(argName.endsWith('reject') ? 'mockRejectedValue' : 'mockResolvedValue', isOnce);
+      context.report({
+        node: property,
+        messageId: 'useMockShorthand',
+        data: {
+          replacement
+        },
+        fix(fixer) {
+          const {
+            sourceCode
+          } = context;
+
+          // there shouldn't be more than one argument, but if there is don't try
+          // fixing since we have no idea what to do with the extra arguments
+          if (innerArgNode.arguments.length > 1) {
+            return null;
+          }
+          return [fixer.replaceText(property, replacement), fixer.replaceText(outerArgNode,
+          // the value argument for both Promise methods is optional,
+          // whereas for Jest they're required so use an explicit undefined
+          // if no argument is being passed to the call we're replacing
+          innerArgNode.arguments.length === 1 ? sourceCode.getText(innerArgNode.arguments[0]) : 'undefined')];
+        }
+      });
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(node.callee.property) || node.arguments.length === 0) {
+          return;
+        }
+        const mockFnName = (0, _utils2.getAccessorValue)(node.callee.property);
+        const isOnce = mockFnName.endsWith('Once');
+        if (mockFnName === withOnce('mockReturnValue', isOnce)) {
+          report(node.callee.property, isOnce, node.arguments[0]);
+        } else if (mockFnName === withOnce('mockImplementation', isOnce)) {
+          const [arg] = node.arguments;
+          if (!(0, _utils2.isFunction)(arg) || arg.params.length !== 0) {
+            return;
+          }
+          report(node.callee.property, isOnce, arg, findSingleReturnArgumentNode(arg));
+        }
+      }
+    };
+  }
+});

package/lib/rules/prefer-mock-return-shorthand.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const withOnce = (name, addOnce) => {
+  return `${name}${addOnce ? 'Once' : ''}`;
+};
+const findSingleReturnArgumentNode = fnNode => {
+  if (fnNode.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+    return fnNode.body;
+  }
+  if (fnNode.body.body[0]?.type === _utils.AST_NODE_TYPES.ReturnStatement) {
+    return fnNode.body.body[0].argument;
+  }
+  return null;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer mock return shorthands'
+    },
+    messages: {
+      useMockShorthand: 'Prefer {{ replacement }}'
+    },
+    schema: [],
+    type: 'suggestion',
+    fixable: 'code'
+  },
+  defaultOptions: [],
+  create(context) {
+    const isMutable = identifier => {
+      const scope = context.sourceCode.getScope(identifier);
+      return scope.through.some(v => v.resolved?.defs.some(n => n.type === 'Variable' && n.parent.kind !== 'const'));
+    };
+    const usesMutableIdentifier = node => {
+      switch (node.type) {
+        case _utils.AST_NODE_TYPES.Identifier:
+          return isMutable(node);
+        case _utils.AST_NODE_TYPES.ObjectExpression:
+          return node.properties.some(prop => usesMutableIdentifier(prop));
+        case _utils.AST_NODE_TYPES.Property:
+          if (node.computed && usesMutableIdentifier(node.key)) {
+            return true;
+          }
+          return usesMutableIdentifier(node.value);
+        case _utils.AST_NODE_TYPES.ArrayExpression:
+          return node.elements.some(el => el && usesMutableIdentifier(el));
+        case _utils.AST_NODE_TYPES.ChainExpression:
+          return usesMutableIdentifier(node.expression);
+        case _utils.AST_NODE_TYPES.SpreadElement:
+        case _utils.AST_NODE_TYPES.UnaryExpression:
+          return usesMutableIdentifier(node.argument);
+        case _utils.AST_NODE_TYPES.LogicalExpression:
+        case _utils.AST_NODE_TYPES.BinaryExpression:
+          return usesMutableIdentifier(node.left) || usesMutableIdentifier(node.right);
+        case _utils.AST_NODE_TYPES.MemberExpression:
+          if (node.computed && usesMutableIdentifier(node.property)) {
+            return true;
+          }
+          return node.object.type === _utils.AST_NODE_TYPES.CallExpression && usesMutableIdentifier(node.object);
+        case _utils.AST_NODE_TYPES.ConditionalExpression:
+          return usesMutableIdentifier(node.test) || usesMutableIdentifier(node.alternate) || usesMutableIdentifier(node.consequent);
+        case _utils.AST_NODE_TYPES.NewExpression:
+        case _utils.AST_NODE_TYPES.CallExpression:
+          return usesMutableIdentifier(node.callee) || node.arguments.some(arg => usesMutableIdentifier(arg));
+      }
+
+      // currently we assume a mutable identifier is not being used
+      // unless we can find one specifically, which is technically
+      // not safe but so far it has not seemed to cause issues.
+      //
+      // if it proves to be too troublesome, we should consider
+      // inverting this so we only report when we're completely
+      // sure it is safe
+      return false;
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(node.callee.property) || node.arguments.length === 0) {
+          return;
+        }
+        const {
+          property
+        } = node.callee;
+        const mockFnName = (0, _utils2.getAccessorValue)(property);
+        const isOnce = mockFnName.endsWith('Once');
+        if (mockFnName !== withOnce('mockImplementation', isOnce)) {
+          return;
+        }
+        const [arg] = node.arguments;
+        if (!(0, _utils2.isFunction)(arg) || arg.params.length !== 0 || arg.async) {
+          return;
+        }
+        const replacement = withOnce('mockReturnValue', isOnce);
+        const returnNode = findSingleReturnArgumentNode(arg);
+        if (!returnNode || returnNode.type === _utils.AST_NODE_TYPES.UpdateExpression) {
+          return;
+        }
+
+        // check if we're using a non-constant variable
+        if (usesMutableIdentifier(returnNode)) {
+          return;
+        }
+        context.report({
+          node: property,
+          messageId: 'useMockShorthand',
+          data: {
+            replacement
+          },
+          fix(fixer) {
+            return [fixer.replaceText(property, replacement), fixer.replaceText(arg, context.sourceCode.getText(returnNode))];
+          }
+        });
+      }
+    };
+  }
+});

package/lib/rules/prefer-snapshot-hint.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+const snapshotMatchers = ['toMatchSnapshot', 'toThrowErrorMatchingSnapshot'];
+const snapshotMatcherNames = snapshotMatchers;
+const isSnapshotMatcherWithoutHint = expectFnCall => {
+  if (expectFnCall.args.length === 0) {
+    return true;
+  }
+
+  // this matcher only supports one argument which is the hint
+  if (!(0, _utils.isSupportedAccessor)(expectFnCall.matcher, 'toMatchSnapshot')) {
+    return expectFnCall.args.length !== 1;
+  }
+
+  // if we're being passed two arguments,
+  // the second one should be the hint
+  if (expectFnCall.args.length === 2) {
+    return false;
+  }
+  const [arg] = expectFnCall.args;
+
+  // the first argument to `toMatchSnapshot` can be _either_ a snapshot hint or
+  // an object with asymmetric matchers, so we can't just assume that the first
+  // argument is a hint when it's by itself.
+  return !(0, _utils.isStringNode)(arg);
+};
+const messages = {
+  missingHint: 'You should provide a hint for this snapshot'
+};
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer including a hint with external snapshots'
+    },
+    messages,
+    type: 'suggestion',
+    schema: [{
+      type: 'string',
+      enum: ['always', 'multi']
+    }]
+  },
+  defaultOptions: ['multi'],
+  create(context, [mode]) {
+    const snapshotMatchers = [];
+    const depths = [];
+    let expressionDepth = 0;
+    const reportSnapshotMatchersWithoutHints = () => {
+      for (const snapshotMatcher of snapshotMatchers) {
+        if (isSnapshotMatcherWithoutHint(snapshotMatcher)) {
+          context.report({
+            messageId: 'missingHint',
+            node: snapshotMatcher.matcher
+          });
+        }
+      }
+    };
+    const enterExpression = () => {
+      expressionDepth++;
+    };
+    const exitExpression = () => {
+      expressionDepth--;
+      if (mode === 'always') {
+        reportSnapshotMatchersWithoutHints();
+        snapshotMatchers.length = 0;
+      }
+      if (mode === 'multi' && expressionDepth === 0) {
+        if (snapshotMatchers.length > 1) {
+          reportSnapshotMatchersWithoutHints();
+        }
+        snapshotMatchers.length = 0;
+      }
+    };
+    return {
+      'Program:exit'() {
+        enterExpression();
+        exitExpression();
+      },
+      FunctionExpression: enterExpression,
+      'FunctionExpression:exit': exitExpression,
+      ArrowFunctionExpression: enterExpression,
+      'ArrowFunctionExpression:exit': exitExpression,
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe', 'test'])) {
+          /* istanbul ignore next */
+          expressionDepth = depths.pop() ?? 0;
+        }
+      },
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          if (jestFnCall?.type === 'describe' || jestFnCall?.type === 'test') {
+            depths.push(expressionDepth);
+            expressionDepth = 0;
+          }
+          return;
+        }
+        const matcherName = (0, _utils.getAccessorValue)(jestFnCall.matcher);
+        if (!snapshotMatcherNames.includes(matcherName)) {
+          return;
+        }
+        snapshotMatchers.push(jestFnCall);
+      }
+    };
+  }
+});