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

package/lib/rules/utils/ts.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBuiltinSymbolLike = isBuiltinSymbolLike;
+let SymbolFlags;
+let TypeFlags;
+function isSymbolFromDefaultLibrary(program, symbol) {
+  /* istanbul ignore next */
+  const declarations = symbol.getDeclarations() ?? [];
+  for (const declaration of declarations) {
+    const sourceFile = declaration.getSourceFile();
+
+    /* istanbul ignore else */
+    if (program.isSourceFileDefaultLibrary(sourceFile)) {
+      return true;
+    }
+  }
+
+  /* istanbul ignore next */
+  return false;
+}
+function isBuiltinSymbolLike(program, type, symbolName) {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  ({
+    TypeFlags,
+    SymbolFlags
+  } = require('typescript'));
+  return isBuiltinSymbolLikeRecurser(program, type, subType => {
+    const symbol = subType.getSymbol();
+    if (!symbol) {
+      return false;
+    }
+    const actualSymbolName = symbol.getName();
+    if (actualSymbolName === symbolName && isSymbolFromDefaultLibrary(program, symbol)) {
+      return true;
+    }
+    return null;
+  });
+}
+function isBuiltinSymbolLikeRecurser(program, type, predicate) {
+  if (type.isIntersection()) {
+    return type.types.some(t => isBuiltinSymbolLikeRecurser(program, t, predicate));
+  }
+  if (type.isUnion()) {
+    return type.types.every(t => isBuiltinSymbolLikeRecurser(program, t, predicate));
+  }
+  if (isTypeParameter(type)) {
+    const t = type.getConstraint();
+    if (t) {
+      return isBuiltinSymbolLikeRecurser(program, t, predicate);
+    }
+    return false;
+  }
+  const predicateResult = predicate(type);
+  if (typeof predicateResult === 'boolean') {
+    return predicateResult;
+  }
+  const symbol = type.getSymbol();
+  if (symbol && symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+    const checker = program.getTypeChecker();
+    for (const baseType of checker.getBaseTypes(type)) {
+      if (isBuiltinSymbolLikeRecurser(program, baseType, predicate)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isTypeParameter(type) {
+  return (type.flags & TypeFlags.TypeParameter) !== 0;
+}

package/lib/rules/valid-describe-callback.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const paramsLocation = params => {
+  const [first] = params;
+  const last = params[params.length - 1];
+  return {
+    start: first.loc.start,
+    end: last.loc.end
+  };
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce valid `describe()` callback'
+    },
+    messages: {
+      nameAndCallback: 'Describe requires name and callback arguments',
+      secondArgumentMustBeFunction: 'Second argument must be function',
+      noAsyncDescribeCallback: 'No async describe callback',
+      unexpectedDescribeArgument: 'Unexpected argument(s) in describe callback',
+      unexpectedReturnInDescribe: 'Unexpected return statement in describe callback'
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'describe') {
+          return;
+        }
+        if (node.arguments.length < 1) {
+          context.report({
+            messageId: 'nameAndCallback',
+            loc: node.loc
+          });
+          return;
+        }
+        const [, callback] = node.arguments;
+        if (!callback) {
+          context.report({
+            messageId: 'nameAndCallback',
+            loc: paramsLocation(node.arguments)
+          });
+          return;
+        }
+        if (!(0, _utils2.isFunction)(callback)) {
+          context.report({
+            messageId: 'secondArgumentMustBeFunction',
+            loc: paramsLocation(node.arguments)
+          });
+          return;
+        }
+        if (callback.async) {
+          context.report({
+            messageId: 'noAsyncDescribeCallback',
+            node: callback
+          });
+        }
+        if (jestFnCall.members.every(s => (0, _utils2.getAccessorValue)(s) !== 'each') && callback.params.length) {
+          context.report({
+            messageId: 'unexpectedDescribeArgument',
+            loc: paramsLocation(callback.params)
+          });
+        }
+        if (callback.body.type === _utils.AST_NODE_TYPES.CallExpression) {
+          context.report({
+            messageId: 'unexpectedReturnInDescribe',
+            node: callback
+          });
+        }
+        if (callback.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
+          callback.body.body.forEach(node => {
+            if (node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
+              context.report({
+                messageId: 'unexpectedReturnInDescribe',
+                node
+              });
+            }
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/valid-expect-in-promise.js

@@ -0,0 +1,311 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const isPromiseChainCall = node => {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property)) {
+    // promise methods should have at least 1 argument
+    if (node.arguments.length === 0) {
+      return false;
+    }
+    switch ((0, _utils2.getAccessorValue)(node.callee.property)) {
+      case 'then':
+        return node.arguments.length < 3;
+      case 'catch':
+      case 'finally':
+        return node.arguments.length < 2;
+    }
+  }
+  return false;
+};
+const isTestCaseCallWithCallbackArg = (node, context) => {
+  const jestCallFn = (0, _utils2.parseJestFnCall)(node, context);
+  if (jestCallFn?.type !== 'test') {
+    return false;
+  }
+  const isJestEach = jestCallFn.members.some(s => (0, _utils2.getAccessorValue)(s) === 'each');
+  if (isJestEach && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+    // isJestEach but not a TaggedTemplateExpression, so this must be
+    // the `jest.each([])()` syntax which this rule doesn't support due
+    // to its complexity (see jest-community/eslint-plugin-jest#710)
+    // so we return true to trigger bailout
+    return true;
+  }
+  const [, callback] = node.arguments;
+  const callbackArgIndex = Number(isJestEach);
+  return callback && (0, _utils2.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
+};
+const isPromiseMethodThatUsesValue = (node, identifier) => {
+  const {
+    name
+  } = identifier;
+  if (node.argument === null) {
+    return false;
+  }
+  if (node.argument.type === _utils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
+    const nodeName = (0, _utils2.getNodeName)(node.argument);
+    if (['Promise.all', 'Promise.allSettled'].includes(nodeName)) {
+      const [firstArg] = node.argument.arguments;
+      if (firstArg.type === _utils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some(nod => nod && (0, _utils2.isIdentifier)(nod, name))) {
+        return true;
+      }
+    }
+    if (['Promise.resolve', 'Promise.reject'].includes(nodeName) && node.argument.arguments.length === 1) {
+      return (0, _utils2.isIdentifier)(node.argument.arguments[0], name);
+    }
+  }
+  return (0, _utils2.isIdentifier)(node.argument, name);
+};
+
+/**
+ * Attempts to determine if the runtime value represented by the given `identifier`
+ * is `await`ed within the given array of elements
+ */
+const isValueAwaitedInElements = (name, elements) => {
+  for (const element of elements) {
+    if (element?.type === _utils.AST_NODE_TYPES.AwaitExpression && (0, _utils2.isIdentifier)(element.argument, name)) {
+      return true;
+    }
+    if (element?.type === _utils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Attempts to determine if the runtime value represented by the given `identifier`
+ * is `await`ed as an argument along the given call expression
+ */
+const isValueAwaitedInArguments = (name, call) => {
+  let node = call;
+  while (node) {
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
+      if (isValueAwaitedInElements(name, node.arguments)) {
+        return true;
+      }
+      node = node.callee;
+    }
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+      break;
+    }
+    node = node.object;
+  }
+  return false;
+};
+const getLeftMostCallExpression = call => {
+  let leftMostCallExpression = call;
+  let node = call;
+  while (node) {
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
+      leftMostCallExpression = node;
+      node = node.callee;
+    }
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+      break;
+    }
+    node = node.object;
+  }
+  return leftMostCallExpression;
+};
+
+/**
+ * Attempts to determine if the runtime value represented by the given `identifier`
+ * is `await`ed or `return`ed within the given `body` of statements
+ */
+const isValueAwaitedOrReturned = (identifier, body, context) => {
+  const {
+    name
+  } = identifier;
+  for (const node of body) {
+    // skip all nodes that are before this identifier, because they'd probably
+    // be affecting a different runtime value (e.g. due to reassignment)
+    if (node.range[0] <= identifier.range[0]) {
+      continue;
+    }
+    if (node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
+      return isPromiseMethodThatUsesValue(node, identifier);
+    }
+    if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
+      // it's possible that we're awaiting the value as an argument
+      if (node.expression.type === _utils.AST_NODE_TYPES.CallExpression) {
+        if (isValueAwaitedInArguments(name, node.expression)) {
+          return true;
+        }
+        const leftMostCall = getLeftMostCallExpression(node.expression);
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node.expression, context);
+        if (jestFnCall?.type === 'expect' && leftMostCall.arguments.length > 0 && (0, _utils2.isIdentifier)(leftMostCall.arguments[0], name)) {
+          if (jestFnCall.members.some(m => {
+            const v = (0, _utils2.getAccessorValue)(m);
+            return v === _utils2.ModifierName.resolves || v === _utils2.ModifierName.rejects;
+          })) {
+            return true;
+          }
+        }
+      }
+      if (node.expression.type === _utils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) {
+        return true;
+      }
+
+      // (re)assignment changes the runtime value, so if we've not found an
+      // await or return already we act as if we've reached the end of the body
+      if (node.expression.type === _utils.AST_NODE_TYPES.AssignmentExpression) {
+        // unless we're assigning to the same identifier, in which case
+        // we might be chaining off the existing promise value
+        if ((0, _utils2.isIdentifier)(node.expression.left, name) && (0, _utils2.getNodeName)(node.expression.right)?.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
+          continue;
+        }
+        break;
+      }
+    }
+    if (node.type === _utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body, context)) {
+      return true;
+    }
+  }
+  return false;
+};
+const findFirstBlockBodyUp = node => {
+  let parent = node;
+  while (parent) {
+    if (parent.type === _utils.AST_NODE_TYPES.BlockStatement) {
+      return parent.body;
+    }
+    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 isDirectlyWithinTestCaseCall = (node, context) => {
+  let parent = node;
+  while (parent) {
+    if ((0, _utils2.isFunction)(parent)) {
+      parent = parent.parent;
+      return parent.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTypeOfJestFnCall)(parent, context, ['test']);
+    }
+    parent = parent.parent;
+  }
+  return false;
+};
+const isVariableAwaitedOrReturned = (variable, context) => {
+  const body = findFirstBlockBodyUp(variable);
+
+  // it's pretty much impossible for us to track destructuring assignments,
+  // so we return true to bailout gracefully
+  if (!(0, _utils2.isIdentifier)(variable.id)) {
+    return true;
+  }
+  return isValueAwaitedOrReturned(variable.id, body, context);
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Require promises that have expectations in their chain to be valid'
+    },
+    messages: {
+      expectInFloatingPromise: 'This promise should either be returned or awaited to ensure the expects in its chain are called'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    let inTestCaseWithDoneCallback = false;
+    // an array of booleans representing each promise chain we enter, with the
+    // boolean value representing if we think a given chain contains an expect
+    // in it's body.
+    //
+    // since we only care about the inner-most chain, we represent the state in
+    // reverse with the inner-most being the first item, as that makes it
+    // slightly less code to assign to by not needing to know the length
+    const chains = [];
+    return {
+      CallExpression(node) {
+        // there are too many ways that the done argument could be used with
+        // promises that contain expect that would make the promise safe for us
+        if (isTestCaseCallWithCallbackArg(node, context)) {
+          inTestCaseWithDoneCallback = true;
+          return;
+        }
+
+        // if this call expression is a promise chain, add it to the stack with
+        // value of "false", as we assume there are no expect calls initially
+        if (isPromiseChainCall(node)) {
+          chains.unshift(false);
+          return;
+        }
+
+        // if we're within a promise chain, and this call expression looks like
+        // an expect call, mark the deepest chain as having an expect call
+        if (chains.length > 0 && (0, _utils2.isTypeOfJestFnCall)(node, context, ['expect'])) {
+          chains[0] = true;
+        }
+      },
+      'CallExpression:exit'(node) {
+        // there are too many ways that the "done" argument could be used to
+        // make promises containing expects safe in a test for us to be able to
+        // accurately check, so we just bail out completely if it's present
+        if (inTestCaseWithDoneCallback) {
+          if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+            inTestCaseWithDoneCallback = false;
+          }
+          return;
+        }
+        if (!isPromiseChainCall(node)) {
+          return;
+        }
+
+        // since we're exiting this call expression (which is a promise chain)
+        // we remove it from the stack of chains, since we're unwinding
+        const hasExpectCall = chains.shift();
+
+        // if the promise chain we're exiting doesn't contain an expect,
+        // then we don't need to check it for anything
+        if (!hasExpectCall) {
+          return;
+        }
+        const {
+          parent
+        } = (0, _utils2.findTopMostCallExpression)(node);
+
+        // if our parent is not directly within the test case, we stop checking
+        // because we're most likely in the body of a function being defined
+        // within the test, which we can't track
+        if (!isDirectlyWithinTestCaseCall(parent, context)) {
+          return;
+        }
+        switch (parent.type) {
+          case _utils.AST_NODE_TYPES.VariableDeclarator:
+            {
+              if (isVariableAwaitedOrReturned(parent, context)) {
+                return;
+              }
+              break;
+            }
+          case _utils.AST_NODE_TYPES.AssignmentExpression:
+            {
+              if (parent.left.type === _utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent), context)) {
+                return;
+              }
+              break;
+            }
+          case _utils.AST_NODE_TYPES.ExpressionStatement:
+            break;
+          case _utils.AST_NODE_TYPES.ReturnStatement:
+          case _utils.AST_NODE_TYPES.AwaitExpression:
+          default:
+            return;
+        }
+        context.report({
+          messageId: 'expectInFloatingPromise',
+          node: parent
+        });
+      }
+    };
+  }
+});

package/lib/rules/valid-expect-with-promise.js

@@ -0,0 +1,54 @@
+"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: 'Require that `resolve` and `reject` modifiers are present (and only) for promise-like types',
+      requiresTypeChecking: true
+    },
+    messages: {
+      poorlyExpectedPromise: 'Subject is a promise so resolve or reject should be used',
+      unneededRejectResolve: 'Subject is not a promise so {{ modifier }} is not needed'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = _utils.ESLintUtils.getParserServices(context);
+    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 [argument] = jestFnCall.head.node.parent.arguments;
+        const isPromiseLike = (0, _utils2.isBuiltinSymbolLike)(services.program, services.getTypeAtLocation(argument), 'Promise');
+        const promiseModifier = jestFnCall.modifiers.find(nod => (0, _utils2.getAccessorValue)(nod) !== 'not');
+        if (isPromiseLike && !promiseModifier) {
+          context.report({
+            messageId: 'poorlyExpectedPromise',
+            node
+          });
+          return;
+        }
+        if (!isPromiseLike && promiseModifier) {
+          context.report({
+            messageId: 'unneededRejectResolve',
+            data: {
+              modifier: (0, _utils2.getAccessorValue)(promiseModifier)
+            },
+            node: promiseModifier
+          });
+        }
+      }
+    };
+  }
+});