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

package/lib/rules/valid-expect.js

@@ -0,0 +1,302 @@
+"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 ported from from eslint-plugin-jasmine.
+ * MIT license, Tom Vincent.
+ */
+
+/**
+ * Async assertions might be called in Promise
+ * methods like `Promise.x(expect1)` or `Promise.x([expect1, expect2])`.
+ * If that's the case, Promise node have to be awaited or returned.
+ *
+ * @Returns CallExpressionNode
+ */
+const getPromiseCallExpressionNode = node => {
+  if (node.type === _utils.AST_NODE_TYPES.ArrayExpression && node.parent.type === _utils.AST_NODE_TYPES.CallExpression) {
+    node = node.parent;
+  }
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object, 'Promise')) {
+    return node;
+  }
+  return null;
+};
+const findPromiseCallExpressionNode = node => node.parent?.parent && [_utils.AST_NODE_TYPES.CallExpression, _utils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
+const findFirstFunctionExpression = ({
+  parent
+}) => {
+  if (!parent) {
+    return null;
+  }
+  return (0, _utils2.isFunction)(parent) ? parent : findFirstFunctionExpression(parent);
+};
+const getNormalizeFunctionExpression = functionExpression => {
+  if (functionExpression.parent.type === _utils.AST_NODE_TYPES.Property && functionExpression.type === _utils.AST_NODE_TYPES.FunctionExpression) {
+    return functionExpression.parent;
+  }
+  return functionExpression;
+};
+const getParentIfThenified = node => {
+  const grandParentNode = node.parent?.parent;
+  if (grandParentNode && grandParentNode.type === _utils.AST_NODE_TYPES.CallExpression && grandParentNode.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(grandParentNode.callee.property) && ['then', 'catch'].includes((0, _utils2.getAccessorValue)(grandParentNode.callee.property))) {
+    // Just in case `then`s are chained look one above.
+    return getParentIfThenified(grandParentNode);
+  }
+  return node;
+};
+const isAcceptableReturnNode = (node, allowReturn) => {
+  if (allowReturn && node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
+    return true;
+  }
+  if (node.type === _utils.AST_NODE_TYPES.ConditionalExpression) {
+    return isAcceptableReturnNode(node.parent, allowReturn);
+  }
+  return [_utils.AST_NODE_TYPES.ArrowFunctionExpression, _utils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
+};
+const promiseArrayExceptionKey = ({
+  start,
+  end
+}) => `${start.line}:${start.column}-${end.line}:${end.column}`;
+const defaultAsyncMatchers = ['toReject', 'toResolve'];
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Enforce valid `expect()` usage'
+    },
+    messages: {
+      tooManyArgs: 'Expect takes at most {{ amount }} argument{{ s }}',
+      notEnoughArgs: 'Expect requires at least {{ amount }} argument{{ s }}',
+      modifierUnknown: 'Expect has an unknown modifier',
+      matcherNotFound: 'Expect must have a corresponding matcher call',
+      matcherNotCalled: 'Matchers must be called to assert',
+      asyncMustBeAwaited: 'Async assertions must be awaited{{ orReturned }}',
+      promisesWithAsyncAssertionsMustBeAwaited: 'Promises which return async assertions must be awaited{{ orReturned }}'
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        alwaysAwait: {
+          type: 'boolean',
+          default: false
+        },
+        asyncMatchers: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        },
+        minArgs: {
+          type: 'number',
+          minimum: 0
+        },
+        maxArgs: {
+          type: 'number',
+          minimum: 1
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    alwaysAwait: false,
+    asyncMatchers: defaultAsyncMatchers,
+    minArgs: 1,
+    maxArgs: 1
+  }],
+  create(context, [{
+    alwaysAwait,
+    asyncMatchers = defaultAsyncMatchers,
+    minArgs = 1,
+    maxArgs = 1
+  }]) {
+    // Context state
+    const arrayExceptions = new Set();
+    const descriptors = [];
+    const pushPromiseArrayException = loc => arrayExceptions.add(promiseArrayExceptionKey(loc));
+
+    /**
+     * Promise method that accepts an array of promises,
+     * (eg. Promise.all), will throw warnings for the each
+     * unawaited or non-returned promise. To avoid throwing
+     * multiple warnings, we check if there is a warning in
+     * the given location.
+     */
+    const promiseArrayExceptionExists = loc => arrayExceptions.has(promiseArrayExceptionKey(loc));
+    const findTopMostMemberExpression = node => {
+      let topMostMemberExpression = node;
+      let {
+        parent
+      } = node;
+      while (parent) {
+        if (parent.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+          break;
+        }
+        topMostMemberExpression = parent;
+        parent = parent.parent;
+      }
+      return topMostMemberExpression;
+    };
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCallWithReason)(node, context);
+        if (typeof jestFnCall === 'string') {
+          const reportingNode = node.parent.type === _utils.AST_NODE_TYPES.MemberExpression ? findTopMostMemberExpression(node.parent).property : node;
+          if (jestFnCall === 'matcher-not-found') {
+            context.report({
+              messageId: 'matcherNotFound',
+              node: reportingNode
+            });
+            return;
+          }
+          if (jestFnCall === 'matcher-not-called') {
+            context.report({
+              messageId: (0, _utils2.isSupportedAccessor)(reportingNode) && _utils2.ModifierName.hasOwnProperty((0, _utils2.getAccessorValue)(reportingNode)) ? 'matcherNotFound' : 'matcherNotCalled',
+              node: reportingNode
+            });
+          }
+          if (jestFnCall === 'modifier-unknown') {
+            context.report({
+              messageId: 'modifierUnknown',
+              node: reportingNode
+            });
+            return;
+          }
+          return;
+        } else if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          parent: expect
+        } = jestFnCall.head.node;
+        if (expect.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+        if (expect.arguments.length < minArgs) {
+          const expectLength = (0, _utils2.getAccessorValue)(jestFnCall.head.node).length;
+          const loc = {
+            start: {
+              column: expect.loc.start.column + expectLength,
+              line: expect.loc.start.line
+            },
+            end: {
+              column: expect.loc.start.column + expectLength + 1,
+              line: expect.loc.start.line
+            }
+          };
+          context.report({
+            messageId: 'notEnoughArgs',
+            data: {
+              amount: minArgs,
+              s: minArgs === 1 ? '' : 's'
+            },
+            node: expect,
+            loc
+          });
+        }
+        if (expect.arguments.length > maxArgs) {
+          const {
+            start
+          } = expect.arguments[maxArgs].loc;
+          const {
+            end
+          } = expect.arguments[expect.arguments.length - 1].loc;
+          const loc = {
+            start,
+            end: {
+              column: end.column - 1,
+              line: end.line
+            }
+          };
+          context.report({
+            messageId: 'tooManyArgs',
+            data: {
+              amount: maxArgs,
+              s: maxArgs === 1 ? '' : 's'
+            },
+            node: expect,
+            loc
+          });
+        }
+        const {
+          matcher
+        } = jestFnCall;
+        const parentNode = matcher.parent.parent;
+        const shouldBeAwaited = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) !== 'not') || asyncMatchers.includes((0, _utils2.getAccessorValue)(matcher));
+        if (!parentNode.parent || !shouldBeAwaited) {
+          return;
+        }
+        /**
+         * If parent node is an array expression, we'll report the warning,
+         * for the array object, not for each individual assertion.
+         */
+        const isParentArrayExpression = parentNode.parent.type === _utils.AST_NODE_TYPES.ArrayExpression;
+        /**
+         * An async assertion can be chained with `then` or `catch` statements.
+         * In that case our target CallExpression node is the one with
+         * the last `then` or `catch` statement.
+         */
+        const targetNode = getParentIfThenified(parentNode);
+        const finalNode = findPromiseCallExpressionNode(targetNode) || targetNode;
+        if (finalNode.parent &&
+        // If node is not awaited or returned
+        !isAcceptableReturnNode(finalNode.parent, !alwaysAwait) &&
+        // if we didn't warn user already
+        !promiseArrayExceptionExists(finalNode.loc)) {
+          descriptors.push({
+            node: finalNode,
+            messageId: targetNode === finalNode ? 'asyncMustBeAwaited' : 'promisesWithAsyncAssertionsMustBeAwaited'
+          });
+        }
+        if (isParentArrayExpression) {
+          pushPromiseArrayException(finalNode.loc);
+        }
+      },
+      'Program:exit'() {
+        const fixes = [];
+        descriptors.forEach(({
+          node,
+          messageId
+        }, index) => {
+          const orReturned = alwaysAwait ? '' : ' or returned';
+          context.report({
+            loc: node.loc,
+            data: {
+              orReturned
+            },
+            messageId,
+            node,
+            fix(fixer) {
+              const functionExpression = findFirstFunctionExpression(node);
+              if (!functionExpression) {
+                return null;
+              }
+              const foundAsyncFixer = fixes.some(fix => fix.text === 'async ');
+              if (!functionExpression.async && !foundAsyncFixer) {
+                const targetFunction = getNormalizeFunctionExpression(functionExpression);
+                fixes.push(fixer.insertTextBefore(targetFunction, 'async '));
+              }
+              const returnStatement = node.parent?.type === _utils.AST_NODE_TYPES.ReturnStatement ? node.parent : null;
+              if (alwaysAwait && returnStatement) {
+                const sourceCodeText = context.sourceCode.getText(returnStatement);
+                const replacedText = sourceCodeText.replace('return', 'await');
+                fixes.push(fixer.replaceText(returnStatement, replacedText));
+              } else {
+                fixes.push(fixer.insertTextBefore(node, 'await '));
+              }
+              return index === descriptors.length - 1 ? fixes : null;
+            }
+          });
+        });
+      }
+    };
+  }
+});

package/lib/rules/valid-mock-module-path.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow mocking of non-existing module paths'
+    },
+    messages: {
+      invalidMockModulePath: 'Module path {{ moduleName }} does not exist or is not exported'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        moduleFileExtensions: {
+          type: 'array',
+          items: {
+            type: 'string'
+          },
+          additionalItems: false
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    moduleFileExtensions: ['.js', '.ts', '.tsx', '.jsx', '.json']
+  }],
+  create(context, [{
+    moduleFileExtensions = ['.js', '.ts', '.tsx', '.jsx', '.json']
+  }]) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        if (!node.arguments.length || !(0, _utils2.isTypeOfJestFnCall)(node, context, ['jest']) || !((0, _utils2.isSupportedAccessor)(node.callee.property) && ['mock', 'doMock'].includes((0, _utils2.getAccessorValue)(node.callee.property)))) {
+          return;
+        }
+        const moduleName = (0, _utils2.findModuleName)(node.arguments[0]);
+        if (!moduleName) {
+          return;
+        }
+        try {
+          if (!moduleName.value.startsWith('.')) {
+            require.resolve(moduleName.value);
+            return;
+          }
+          const resolvedModulePath = _path.default.resolve(_path.default.dirname(context.filename), moduleName.value);
+          const hasPossiblyModulePaths = ['', ...moduleFileExtensions].some(ext => {
+            try {
+              (0, _fs.statSync)(`${resolvedModulePath}${ext}`);
+              return true;
+            } catch {
+              return false;
+            }
+          });
+          if (hasPossiblyModulePaths) {
+            return;
+          }
+        } catch (err) {
+          const castedErr = err;
+
+          // Reports unexpected issues when attempt to verify mocked module path.
+          // The list of possible errors is non-exhaustive.
+          if (castedErr.code !== 'MODULE_NOT_FOUND' && castedErr.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            throw new Error(`Error when trying to validate mock module path from \`jest.mock\`: ${err}`);
+          }
+        }
+        context.report({
+          messageId: 'invalidMockModulePath',
+          data: {
+            moduleName: moduleName.raw
+          },
+          node
+        });
+      }
+    };
+  }
+});

package/lib/rules/valid-title.js

@@ -0,0 +1,252 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const trimFXprefix = word => ['f', 'x'].includes(word.charAt(0)) ? word.substring(1) : word;
+const doesBinaryExpressionContainStringNode = binaryExp => {
+  if ((0, _utils2.isStringNode)(binaryExp.right)) {
+    return true;
+  }
+  if (binaryExp.left.type === _utils.AST_NODE_TYPES.BinaryExpression) {
+    return doesBinaryExpressionContainStringNode(binaryExp.left);
+  }
+  return (0, _utils2.isStringNode)(binaryExp.left);
+};
+const quoteStringValue = node => node.type === _utils.AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
+const compileMatcherPattern = matcherMaybeWithMessage => {
+  const [matcher, message] = Array.isArray(matcherMaybeWithMessage) ? matcherMaybeWithMessage : [matcherMaybeWithMessage];
+  return [new RegExp(matcher, 'u'), message];
+};
+const compileMatcherPatterns = matchers => {
+  if (typeof matchers === 'string' || Array.isArray(matchers)) {
+    const compiledMatcher = compileMatcherPattern(matchers);
+    return {
+      describe: compiledMatcher,
+      test: compiledMatcher,
+      it: compiledMatcher
+    };
+  }
+  return {
+    describe: matchers.describe ? compileMatcherPattern(matchers.describe) : null,
+    test: matchers.test ? compileMatcherPattern(matchers.test) : null,
+    it: matchers.it ? compileMatcherPattern(matchers.it) : null
+  };
+};
+
+// %p - pretty-format.
+// %s- String.
+// %d- Number.
+// %i - Integer.
+// %f - Floating point value.
+// %j - JSON.
+// %o - Object.
+// %# - Index of the test case.
+// %$ - Number of the test case.
+// %% - single percent sign ('%'). This does not consume an argument.
+
+// const re = /%([^psdifjo#$%])/u;
+
+const MatcherAndMessageSchema = {
+  type: 'array',
+  items: {
+    type: 'string'
+  },
+  minItems: 1,
+  maxItems: 2,
+  additionalItems: false
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Enforce valid titles'
+    },
+    messages: {
+      titleMustBeString: 'Title must be a string',
+      emptyTitle: '{{ jestFunctionName }} should not have an empty title',
+      duplicatePrefix: 'should not have duplicate prefix',
+      accidentalSpace: 'should not have leading or trailing spaces',
+      disallowedWord: '"{{ word }}" is not allowed in test titles',
+      mustNotMatch: '{{ jestFunctionName }} should not match {{ pattern }}',
+      mustMatch: '{{ jestFunctionName }} should match {{ pattern }}',
+      mustNotMatchCustom: '{{ message }}',
+      mustMatchCustom: '{{ message }}',
+      invalidEachSpecifier: '"{{ specifier }}" is not a valid format specifier'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        ignoreSpaces: {
+          type: 'boolean',
+          default: false
+        },
+        ignoreTypeOfDescribeName: {
+          type: 'boolean',
+          default: false
+        },
+        ignoreTypeOfTestName: {
+          type: 'boolean',
+          default: false
+        },
+        disallowedWords: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      patternProperties: {
+        [/^must(?:Not)?Match$/u.source]: {
+          oneOf: [{
+            type: 'string'
+          }, MatcherAndMessageSchema, {
+            type: 'object',
+            // @ts-expect-error https://github.com/eslint/eslint/discussions/17573
+            propertyNames: {
+              enum: ['describe', 'test', 'it']
+            },
+            additionalProperties: {
+              oneOf: [{
+                type: 'string'
+              }, MatcherAndMessageSchema]
+            }
+          }]
+        }
+      },
+      additionalProperties: false
+    }],
+    fixable: 'code'
+  },
+  defaultOptions: [{
+    ignoreSpaces: false,
+    ignoreTypeOfDescribeName: false,
+    ignoreTypeOfTestName: false,
+    disallowedWords: []
+  }],
+  create(context, [{
+    ignoreSpaces,
+    ignoreTypeOfDescribeName,
+    ignoreTypeOfTestName,
+    disallowedWords = [],
+    mustNotMatch,
+    mustMatch
+  }]) {
+    const disallowedWordsRegexp = new RegExp(`\\b(${disallowedWords.join('|')})\\b`, 'iu');
+    const mustNotMatchPatterns = compileMatcherPatterns(mustNotMatch ?? {});
+    const mustMatchPatterns = compileMatcherPatterns(mustMatch ?? {});
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'describe' && jestFnCall?.type !== 'test') {
+          return;
+        }
+        const [argument] = node.arguments;
+        if (!argument) {
+          return;
+        }
+        if (!(0, _utils2.isStringNode)(argument)) {
+          if (argument.type === _utils.AST_NODE_TYPES.BinaryExpression && doesBinaryExpressionContainStringNode(argument)) {
+            return;
+          }
+          if (!(jestFnCall.type === 'describe' && ignoreTypeOfDescribeName || jestFnCall.type === 'test' && ignoreTypeOfTestName) && argument.type !== _utils.AST_NODE_TYPES.TemplateLiteral) {
+            context.report({
+              messageId: 'titleMustBeString',
+              loc: argument.loc
+            });
+          }
+          return;
+        }
+        const title = (0, _utils2.getStringValue)(argument);
+        if (!title) {
+          context.report({
+            messageId: 'emptyTitle',
+            data: {
+              jestFunctionName: jestFnCall.type === 'describe' ? _utils2.DescribeAlias.describe : _utils2.TestCaseName.test
+            },
+            node
+          });
+          return;
+        }
+
+        // check array-based .each titles for invalid printf specifiers
+        if (jestFnCall.members.find(s => (0, _utils2.isSupportedAccessor)(s, 'each'))?.parent.parent.type === _utils.AST_NODE_TYPES.CallExpression) {
+          const [unknownSpecifier] = /%[^psdifjo#$%]/u.exec(title.replaceAll('%%', '')) ?? [];
+          if (unknownSpecifier) {
+            context.report({
+              messageId: 'invalidEachSpecifier',
+              data: {
+                specifier: unknownSpecifier
+              },
+              node: argument
+            });
+          }
+        }
+        if (disallowedWords.length > 0) {
+          const disallowedMatch = disallowedWordsRegexp.exec(title);
+          if (disallowedMatch) {
+            context.report({
+              data: {
+                word: disallowedMatch[1]
+              },
+              messageId: 'disallowedWord',
+              node: argument
+            });
+            return;
+          }
+        }
+        if (ignoreSpaces === false && title.trim().length !== title.length) {
+          context.report({
+            messageId: 'accidentalSpace',
+            node: argument,
+            fix: fixer => [fixer.replaceTextRange(argument.range, quoteStringValue(argument).replace(/^([`'"]) +?/u, '$1').replace(/ +?([`'"])$/u, '$1'))]
+          });
+        }
+        const unprefixedName = trimFXprefix(jestFnCall.name);
+        const [firstWord] = title.split(' ');
+        if (firstWord.toLowerCase() === unprefixedName) {
+          context.report({
+            messageId: 'duplicatePrefix',
+            node: argument,
+            fix: fixer => [fixer.replaceTextRange(argument.range, quoteStringValue(argument).replace(/^([`'"]).+? /u, '$1'))]
+          });
+        }
+        const jestFunctionName = unprefixedName;
+        const [mustNotMatchPattern, mustNotMatchMessage] = mustNotMatchPatterns[jestFunctionName] ?? [];
+        if (mustNotMatchPattern) {
+          if (mustNotMatchPattern.test(title)) {
+            context.report({
+              messageId: mustNotMatchMessage ? 'mustNotMatchCustom' : 'mustNotMatch',
+              node: argument,
+              data: {
+                jestFunctionName,
+                pattern: mustNotMatchPattern,
+                message: mustNotMatchMessage
+              }
+            });
+            return;
+          }
+        }
+        const [mustMatchPattern, mustMatchMessage] = mustMatchPatterns[jestFunctionName] ?? [];
+        if (mustMatchPattern) {
+          if (!mustMatchPattern.test(title)) {
+            context.report({
+              messageId: mustMatchMessage ? 'mustMatchCustom' : 'mustMatch',
+              node: argument,
+              data: {
+                jestFunctionName,
+                pattern: mustMatchPattern,
+                message: mustMatchMessage
+              }
+            });
+            return;
+          }
+        }
+      }
+    };
+  }
+});