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

package/lib/rules/require-to-throw-message.js

@@ -0,0 +1,45 @@
+"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: 'Require a message for `toThrow()`'
+    },
+    messages: {
+      addErrorMessage: 'Add an error message to {{ matcherName }}()'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherName = (0, _utils.getAccessorValue)(matcher);
+        if (jestFnCall.args.length === 0 && ['toThrow', 'toThrowError'].includes(matcherName) && !jestFnCall.modifiers.some(nod => (0, _utils.getAccessorValue)(nod) === 'not')) {
+          // Look for `toThrow` calls with no arguments.
+          context.report({
+            messageId: 'addErrorMessage',
+            data: {
+              matcherName
+            },
+            node: matcher
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/require-top-level-describe.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+const messages = {
+  tooManyDescribes: 'There should not be more than {{ max }} describe{{ s }} at the top level',
+  unexpectedTestCase: 'All test cases must be wrapped in a describe block.',
+  unexpectedHook: 'All hooks must be wrapped in a describe block.'
+};
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Require test cases and hooks to be inside a `describe` block'
+    },
+    messages,
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        maxNumberOfTopLevelDescribes: {
+          type: 'number',
+          minimum: 1
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{}],
+  create(context) {
+    const {
+      maxNumberOfTopLevelDescribes = Infinity
+    } = context.options[0] ?? {};
+    let numberOfTopLevelDescribeBlocks = 0;
+    let numberOfDescribeBlocks = 0;
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (!jestFnCall) {
+          return;
+        }
+        if (jestFnCall.type === 'describe') {
+          numberOfDescribeBlocks++;
+          if (numberOfDescribeBlocks === 1) {
+            numberOfTopLevelDescribeBlocks++;
+            if (numberOfTopLevelDescribeBlocks > maxNumberOfTopLevelDescribes) {
+              context.report({
+                node,
+                messageId: 'tooManyDescribes',
+                data: {
+                  max: maxNumberOfTopLevelDescribes,
+                  s: maxNumberOfTopLevelDescribes === 1 ? '' : 's'
+                }
+              });
+            }
+          }
+          return;
+        }
+        if (numberOfDescribeBlocks === 0) {
+          if (jestFnCall.type === 'test') {
+            context.report({
+              node,
+              messageId: 'unexpectedTestCase'
+            });
+            return;
+          }
+          if (jestFnCall.type === 'hook') {
+            context.report({
+              node,
+              messageId: 'unexpectedHook'
+            });
+            return;
+          }
+        }
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe'])) {
+          numberOfDescribeBlocks--;
+        }
+      }
+    };
+  }
+});

package/lib/rules/unbound-method.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const toThrowMatchers = ['toThrow', 'toThrowError', 'toThrowErrorMatchingSnapshot', 'toThrowErrorMatchingInlineSnapshot'];
+const baseRule = (() => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const TSESLintPlugin = require('@typescript-eslint/eslint-plugin');
+    return TSESLintPlugin.rules['unbound-method'];
+  } catch (e) {
+    const error = e;
+    if (error.code === 'MODULE_NOT_FOUND') {
+      return null;
+    }
+    throw error;
+  }
+})();
+const DEFAULT_MESSAGE = 'This rule requires `@typescript-eslint/eslint-plugin`';
+var _default = exports.default = (0, _utils2.createRule)({
+  defaultOptions: [{
+    ignoreStatic: false
+  }],
+  ...baseRule,
+  name: __filename,
+  meta: {
+    messages: {
+      unbound: DEFAULT_MESSAGE,
+      unboundWithoutThisAnnotation: DEFAULT_MESSAGE
+    },
+    schema: [],
+    type: 'problem',
+    ...baseRule?.meta,
+    docs: {
+      description: 'Enforce unbound methods are called with their expected scope',
+      ...baseRule?.meta.docs
+    }
+  },
+  create(context) {
+    const baseSelectors = baseRule?.create(context);
+    if (!baseSelectors) {
+      return {};
+    }
+
+    /**
+     * Checks if a MemberExpression is an argument to a `jest.mocked()` call.
+     * This handles cases like `jest.mocked(service.method)` where `service.method`
+     * should not be flagged as an unbound method.
+     */
+    const isArgumentToJestMocked = node => {
+      // Check if the immediate parent is a CallExpression
+      if (node.parent?.type !== _utils.AST_NODE_TYPES.CallExpression) {
+        return false;
+      }
+      const parentCall = node.parent;
+      return parentCall.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(parentCall.callee.object, 'jest') && (0, _utils2.isSupportedAccessor)(parentCall.callee.property, 'mocked');
+    };
+    return {
+      ...baseSelectors,
+      MemberExpression(node) {
+        if (isArgumentToJestMocked(node)) {
+          return;
+        }
+        if (node.parent?.type === _utils.AST_NODE_TYPES.CallExpression) {
+          const jestFnCall = (0, _utils2.parseJestFnCall)((0, _utils2.findTopMostCallExpression)(node.parent), context);
+          if (jestFnCall?.type === 'jest' && jestFnCall.members.length >= 1 && (0, _utils2.isIdentifier)(jestFnCall.members[0], 'mocked')) {
+            return;
+          }
+          if (jestFnCall?.type === 'expect') {
+            const {
+              matcher
+            } = jestFnCall;
+            if (!toThrowMatchers.includes((0, _utils2.getAccessorValue)(matcher))) {
+              return;
+            }
+          }
+        }
+        baseSelectors.MemberExpression?.(node);
+      }
+    };
+  }
+});

package/lib/rules/utils/accessors.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isSupportedAccessor = exports.isStringNode = exports.isIdentifier = exports.getStringValue = exports.getAccessorValue = void 0;
+var _utils = require("@typescript-eslint/utils");
+/**
+ * A `Literal` with a `value` of type `string`.
+ */
+
+/**
+ * Checks if the given `node` is a `StringLiteral`.
+ *
+ * If a `value` is provided & the `node` is a `StringLiteral`,
+ * the `value` will be compared to that of the `StringLiteral`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is StringLiteral<V>}
+ *
+ * @template V
+ */
+const isStringLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
+/**
+ * Checks if the given `node` is a `TemplateLiteral`.
+ *
+ * Complex `TemplateLiteral`s are not considered specific, and so will return `false`.
+ *
+ * If a `value` is provided & the `node` is a `TemplateLiteral`,
+ * the `value` will be compared to that of the `TemplateLiteral`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is TemplateLiteral<V>}
+ *
+ * @template V
+ */
+const isTemplateLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && (
+// bail out if not simple
+value === undefined || node.quasis[0].value.raw === value);
+/**
+ * Checks if the given `node` is a {@link StringNode}.
+ *
+ * @param {Node} node
+ * @param {V} [specifics]
+ *
+ * @return {node is StringNode}
+ *
+ * @template V
+ */
+const isStringNode = (node, specifics) => isStringLiteral(node, specifics) || isTemplateLiteral(node, specifics);
+
+/**
+ * Gets the value of the given `StringNode`.
+ *
+ * If the `node` is a `TemplateLiteral`, the `raw` value is used;
+ * otherwise, `value` is returned instead.
+ *
+ * @param {StringNode<S>} node
+ *
+ * @return {S}
+ *
+ * @template S
+ */
+exports.isStringNode = isStringNode;
+const getStringValue = node => isTemplateLiteral(node) ? node.quasis[0].value.raw : node.value;
+
+/**
+ * An `Identifier` with a known `name` value - i.e `expect`.
+ */
+exports.getStringValue = getStringValue;
+/**
+ * Checks if the given `node` is an `Identifier`.
+ *
+ * If a `name` is provided, & the `node` is an `Identifier`,
+ * the `name` will be compared to that of the `identifier`.
+ *
+ * @param {Node} node
+ * @param {V} [name]
+ *
+ * @return {node is KnownIdentifier<Name>}
+ *
+ * @template V
+ */
+const isIdentifier = (node, name) => node.type === _utils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
+
+/**
+ * Checks if the given `node` is a "supported accessor".
+ *
+ * This means that it's a node can be used to access properties,
+ * and who's "value" can be statically determined.
+ *
+ * `MemberExpression` nodes most commonly contain accessors,
+ * but it's possible for other nodes to contain them.
+ *
+ * If a `value` is provided & the `node` is an `AccessorNode`,
+ * the `value` will be compared to that of the `AccessorNode`.
+ *
+ * Note that `value` here refers to the normalised value.
+ * The property that holds the value is not always called `name`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is AccessorNode<V>}
+ *
+ * @template V
+ */
+exports.isIdentifier = isIdentifier;
+const isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStringNode(node, value);
+
+/**
+ * Gets the value of the given `AccessorNode`,
+ * account for the different node types.
+ *
+ * @param {AccessorNode<S>} accessor
+ *
+ * @return {S}
+ *
+ * @template S
+ */
+exports.isSupportedAccessor = isSupportedAccessor;
+const getAccessorValue = accessor => accessor.type === _utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
+exports.getAccessorValue = getAccessorValue;

package/lib/rules/utils/ast-utils.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidParent = exports.isTokenASemicolon = exports.getPaddingLineSequences = exports.getActualLastToken = exports.areTokensOnSameLine = void 0;
+var _utils = require("@typescript-eslint/utils");
+const isTokenASemicolon = token => token.value === ';' && token.type === _utils.AST_TOKEN_TYPES.Punctuator;
+exports.isTokenASemicolon = isTokenASemicolon;
+const areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+
+// We'll only verify nodes with these parent types
+exports.areTokensOnSameLine = areTokensOnSameLine;
+const STATEMENT_LIST_PARENTS = new Set([_utils.AST_NODE_TYPES.Program, _utils.AST_NODE_TYPES.BlockStatement, _utils.AST_NODE_TYPES.SwitchCase, _utils.AST_NODE_TYPES.SwitchStatement]);
+const isValidParent = parentType => {
+  return STATEMENT_LIST_PARENTS.has(parentType);
+};
+
+/**
+ * Gets the actual last token.
+ *
+ * If a semicolon is semicolon-less style's semicolon, this ignores it.
+ * For example:
+ *
+ *     foo()
+ *     ;[1, 2, 3].forEach(bar)
+ */
+exports.isValidParent = isValidParent;
+const getActualLastToken = (sourceCode, node) => {
+  const semiToken = sourceCode.getLastToken(node);
+  const prevToken = sourceCode.getTokenBefore(semiToken);
+  const nextToken = sourceCode.getTokenAfter(semiToken);
+  const isSemicolonLessStyle = Boolean(prevToken && nextToken && prevToken.range[0] >= node.range[0] && isTokenASemicolon(semiToken) && semiToken.loc.start.line !== prevToken.loc.end.line && semiToken.loc.end.line === nextToken.loc.start.line);
+  return isSemicolonLessStyle ? prevToken : semiToken;
+};
+
+/**
+ * Gets padding line sequences between the given 2 statements.
+ * Comments are separators of the padding line sequences.
+ */
+exports.getActualLastToken = getActualLastToken;
+const getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
+  const pairs = [];
+  const includeComments = true;
+  let prevToken = getActualLastToken(sourceCode, prevNode);
+  if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
+    do {
+      const token = sourceCode.getTokenAfter(prevToken, {
+        includeComments
+      });
+      if (token.loc.start.line - prevToken.loc.end.line >= 2) {
+        pairs.push([prevToken, token]);
+      }
+      prevToken = token;
+    } while (prevToken.range[0] < nextNode.range[0]);
+  }
+  return pairs;
+};
+exports.getPaddingLineSequences = getPaddingLineSequences;

package/lib/rules/utils/detectJestVersion.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detectJestVersion = void 0;
+let cachedJestVersion = null;
+const detectJestVersion = () => {
+  if (cachedJestVersion) {
+    return cachedJestVersion;
+  }
+  try {
+    const jestPath = require.resolve('jest/package.json');
+    const jestPackageJson =
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require(jestPath);
+    if (jestPackageJson.version) {
+      const [majorVersion] = jestPackageJson.version.split('.');
+      return cachedJestVersion = parseInt(majorVersion, 10);
+    }
+  } catch {}
+  throw new Error('Unable to detect Jest version - please ensure jest package is installed, or otherwise set version explicitly');
+};
+exports.detectJestVersion = detectJestVersion;

package/lib/rules/utils/followTypeAssertionChain.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.followTypeAssertionChain = void 0;
+var _utils = require("@typescript-eslint/utils");
+const isTypeCastExpression = node => node.type === _utils.AST_NODE_TYPES.TSAsExpression || node.type === _utils.AST_NODE_TYPES.TSTypeAssertion;
+const followTypeAssertionChain = expression => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
+exports.followTypeAssertionChain = followTypeAssertionChain;

package/lib/rules/utils/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _accessors = require("./accessors");
+Object.keys(_accessors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _accessors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _accessors[key];
+    }
+  });
+});
+var _detectJestVersion = require("./detectJestVersion");
+Object.keys(_detectJestVersion).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _detectJestVersion[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _detectJestVersion[key];
+    }
+  });
+});
+var _followTypeAssertionChain = require("./followTypeAssertionChain");
+Object.keys(_followTypeAssertionChain).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _followTypeAssertionChain[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _followTypeAssertionChain[key];
+    }
+  });
+});
+var _misc = require("./misc");
+Object.keys(_misc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _misc[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _misc[key];
+    }
+  });
+});
+var _parseJestFnCall = require("./parseJestFnCall");
+Object.keys(_parseJestFnCall).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseJestFnCall[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseJestFnCall[key];
+    }
+  });
+});
+var _ts = require("./ts");
+Object.keys(_ts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ts[key];
+    }
+  });
+});

package/lib/rules/utils/misc.js

@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFirstMatcherArg = exports.findTopMostCallExpression = exports.findModuleName = exports.createRule = exports.TestCaseName = exports.ModifierName = exports.HookName = exports.EqualityMatcher = exports.DescribeAlias = void 0;
+exports.getNodeName = getNodeName;
+exports.replaceAccessorFixer = exports.removeExtraArgumentsFixer = exports.isFunction = exports.isBooleanLiteral = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = void 0;
+var _path = require("path");
+var _utils = require("@typescript-eslint/utils");
+var _package = require("../../../package.json");
+var _accessors = require("./accessors");
+var _followTypeAssertionChain = require("./followTypeAssertionChain");
+var _parseJestFnCall = require("./parseJestFnCall");
+const REPO_URL = 'https://github.com/jest-community/eslint-plugin-jest';
+const createRule = exports.createRule = _utils.ESLintUtils.RuleCreator(name => {
+  const ruleName = (0, _path.parse)(name).name;
+  return `${REPO_URL}/blob/v${_package.version}/docs/rules/${ruleName}.md`;
+});
+
+/**
+ * Represents a `MemberExpression` with a "known" `property`.
+ */
+
+/**
+ * Represents a `CallExpression` with a "known" `property` accessor.
+ *
+ * i.e `KnownCallExpression<'includes'>` represents `.includes()`.
+ */
+
+/**
+ * Represents a `MemberExpression` with a "known" `property`, that is called.
+ *
+ * This is `KnownCallExpression` from the perspective of the `MemberExpression` node.
+ */
+
+/**
+ * Represents a `CallExpression` with a single argument.
+ */
+
+/**
+ * Guards that the given `call` has only one `argument`.
+ *
+ * @param {CallExpression} call
+ *
+ * @return {call is CallExpressionWithSingleArgument}
+ */
+const hasOnlyOneArgument = call => call.arguments.length === 1;
+exports.hasOnlyOneArgument = hasOnlyOneArgument;
+let DescribeAlias = exports.DescribeAlias = /*#__PURE__*/function (DescribeAlias) {
+  DescribeAlias["describe"] = "describe";
+  DescribeAlias["fdescribe"] = "fdescribe";
+  DescribeAlias["xdescribe"] = "xdescribe";
+  return DescribeAlias;
+}({});
+let TestCaseName = exports.TestCaseName = /*#__PURE__*/function (TestCaseName) {
+  TestCaseName["fit"] = "fit";
+  TestCaseName["it"] = "it";
+  TestCaseName["test"] = "test";
+  TestCaseName["xit"] = "xit";
+  TestCaseName["xtest"] = "xtest";
+  return TestCaseName;
+}({});
+let HookName = exports.HookName = /*#__PURE__*/function (HookName) {
+  HookName["beforeAll"] = "beforeAll";
+  HookName["beforeEach"] = "beforeEach";
+  HookName["afterAll"] = "afterAll";
+  HookName["afterEach"] = "afterEach";
+  return HookName;
+}({});
+let ModifierName = exports.ModifierName = /*#__PURE__*/function (ModifierName) {
+  ModifierName["not"] = "not";
+  ModifierName["rejects"] = "rejects";
+  ModifierName["resolves"] = "resolves";
+  return ModifierName;
+}({});
+let EqualityMatcher = exports.EqualityMatcher = /*#__PURE__*/function (EqualityMatcher) {
+  EqualityMatcher["toBe"] = "toBe";
+  EqualityMatcher["toEqual"] = "toEqual";
+  EqualityMatcher["toStrictEqual"] = "toStrictEqual";
+  return EqualityMatcher;
+}({});
+const joinNames = (a, b) => a && b ? `${a}.${b}` : null;
+function getNodeName(node) {
+  if ((0, _accessors.isSupportedAccessor)(node)) {
+    return (0, _accessors.getAccessorValue)(node);
+  }
+  switch (node.type) {
+    case _utils.AST_NODE_TYPES.TaggedTemplateExpression:
+      return getNodeName(node.tag);
+    case _utils.AST_NODE_TYPES.MemberExpression:
+      return joinNames(getNodeName(node.object), getNodeName(node.property));
+    case _utils.AST_NODE_TYPES.NewExpression:
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return getNodeName(node.callee);
+  }
+  return null;
+}
+const isFunction = node => node.type === _utils.AST_NODE_TYPES.FunctionExpression || node.type === _utils.AST_NODE_TYPES.ArrowFunctionExpression;
+exports.isFunction = isFunction;
+const getTestCallExpressionsFromDeclaredVariables = (declaredVariables, context) => {
+  return declaredVariables.flatMap(({
+    references
+  }) => references.map(({
+    identifier
+  }) => identifier.parent).filter(node => node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _parseJestFnCall.isTypeOfJestFnCall)(node, context, ['test'])));
+};
+
+/**
+ * Replaces an accessor node with the given `text`, surrounding it in quotes if required.
+ *
+ * This ensures that fixes produce valid code when replacing both dot-based and
+ * bracket-based property accessors.
+ */
+exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;
+const replaceAccessorFixer = (fixer, node, text) => {
+  return fixer.replaceText(node, node.type === _utils.AST_NODE_TYPES.Identifier ? text : `'${text}'`);
+};
+exports.replaceAccessorFixer = replaceAccessorFixer;
+const removeExtraArgumentsFixer = (fixer, context, func, from) => {
+  const firstArg = func.arguments[from];
+  const lastArg = func.arguments[func.arguments.length - 1];
+  const {
+    sourceCode
+  } = context;
+  let tokenAfterLastParam = sourceCode.getTokenAfter(lastArg);
+  if (tokenAfterLastParam.value === ',') {
+    tokenAfterLastParam = sourceCode.getTokenAfter(tokenAfterLastParam);
+  }
+  return fixer.removeRange([firstArg.range[0], tokenAfterLastParam.range[0]]);
+};
+exports.removeExtraArgumentsFixer = removeExtraArgumentsFixer;
+const findTopMostCallExpression = node => {
+  let topMostCallExpression = node;
+  let {
+    parent
+  } = node;
+  while (parent) {
+    if (parent.type === _utils.AST_NODE_TYPES.CallExpression) {
+      topMostCallExpression = parent;
+      parent = parent.parent;
+      continue;
+    }
+    if (parent.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+      break;
+    }
+    parent = parent.parent;
+  }
+  return topMostCallExpression;
+};
+exports.findTopMostCallExpression = findTopMostCallExpression;
+const isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+exports.isBooleanLiteral = isBooleanLiteral;
+const getFirstMatcherArg = expectFnCall => {
+  const [firstArg] = expectFnCall.args;
+  if (firstArg.type === _utils.AST_NODE_TYPES.SpreadElement) {
+    return firstArg;
+  }
+  return (0, _followTypeAssertionChain.followTypeAssertionChain)(firstArg);
+};
+exports.getFirstMatcherArg = getFirstMatcherArg;
+const findModuleName = node => {
+  if (node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+    return node;
+  }
+  return null;
+};
+exports.findModuleName = findModuleName;