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

package/lib/rules/no-deprecated-functions.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const parseJestVersion = rawVersion => {
+  if (typeof rawVersion === 'number') {
+    return rawVersion;
+  }
+  const [majorVersion] = rawVersion.split('.');
+  return parseInt(majorVersion, 10);
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow use of deprecated functions'
+    },
+    messages: {
+      deprecatedFunction: '`{{ deprecation }}` has been deprecated in favor of `{{ replacement }}`'
+    },
+    type: 'suggestion',
+    schema: [],
+    fixable: 'code'
+  },
+  defaultOptions: [],
+  create(context) {
+    const jestVersion = parseJestVersion(context.settings?.jest?.version || (0, _utils2.detectJestVersion)());
+    const deprecations = {
+      ...(jestVersion >= 15 && {
+        'jest.resetModuleRegistry': 'jest.resetModules'
+      }),
+      ...(jestVersion >= 17 && {
+        'jest.addMatchers': 'expect.extend'
+      }),
+      ...(jestVersion >= 21 && {
+        'require.requireMock': 'jest.requireMock',
+        'require.requireActual': 'jest.requireActual'
+      }),
+      ...(jestVersion >= 22 && {
+        'jest.runTimersToTime': 'jest.advanceTimersByTime'
+      }),
+      ...(jestVersion >= 26 && {
+        'jest.genMockFromModule': 'jest.createMockFromModule'
+      })
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        const deprecation = (0, _utils2.getNodeName)(node);
+        if (!deprecation || !(deprecation in deprecations)) {
+          return;
+        }
+        const replacement = deprecations[deprecation];
+        const {
+          callee
+        } = node;
+        context.report({
+          messageId: 'deprecatedFunction',
+          data: {
+            deprecation,
+            replacement
+          },
+          node,
+          fix(fixer) {
+            let [name, func] = replacement.split('.');
+            if (callee.property.type === _utils.AST_NODE_TYPES.Literal) {
+              func = `'${func}'`;
+            }
+            return [fixer.replaceText(callee.object, name), fixer.replaceText(callee.property, func)];
+          }
+        });
+      }
+    };
+  }
+});

package/lib/rules/no-disabled-tests.js

@@ -0,0 +1,57 @@
+"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: 'Disallow disabled tests'
+    },
+    messages: {
+      missingFunction: 'Test is missing function argument',
+      skippedTest: 'Tests should not be skipped'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (!jestFnCall) {
+          return;
+        }
+        if (jestFnCall.type === 'test') {
+          if (node.arguments.length < 2 && jestFnCall.members.every(s => (0, _utils.getAccessorValue)(s) !== 'todo')) {
+            context.report({
+              messageId: 'missingFunction',
+              node
+            });
+          }
+        }
+        if (
+        // the only jest functions that are with "x" are "xdescribe", "xtest", and "xit"
+        jestFnCall.name.startsWith('x') || jestFnCall.members.some(s => (0, _utils.getAccessorValue)(s) === 'skip')) {
+          context.report({
+            messageId: 'skippedTest',
+            node
+          });
+        }
+      },
+      'CallExpression[callee.name="pending"]'(node) {
+        if ((0, _utils.resolveScope)(context.sourceCode.getScope(node), 'pending')) {
+          return;
+        }
+        context.report({
+          messageId: 'skippedTest',
+          node
+        });
+      }
+    };
+  }
+});

package/lib/rules/no-done-callback.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const findCallbackArg = (node, isJestEach, context) => {
+  if (isJestEach) {
+    return node.arguments[1];
+  }
+  const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+  if (jestFnCall?.type === 'hook' && node.arguments.length >= 1) {
+    return node.arguments[0];
+  }
+  if (jestFnCall?.type === 'test' && node.arguments.length >= 2) {
+    return node.arguments[1];
+  }
+  return null;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow using a callback in asynchronous tests and hooks'
+    },
+    messages: {
+      noDoneCallback: 'Return a Promise instead of relying on callback parameter',
+      suggestWrappingInPromise: 'Wrap in `new Promise({{ callback }} => ...`',
+      useAwaitInsteadOfCallback: 'Use await instead of callback in async functions'
+    },
+    schema: [],
+    type: 'suggestion',
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        // done is the second argument for it.each, not the first
+        const isJestEach = (0, _utils2.getNodeName)(node.callee)?.endsWith('.each') ?? false;
+        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)
+          return;
+        }
+        const callback = findCallbackArg(node, isJestEach, context);
+        const callbackArgIndex = Number(isJestEach);
+        if (!callback || !(0, _utils2.isFunction)(callback) || callback.params.length !== 1 + callbackArgIndex) {
+          return;
+        }
+        const argument = callback.params[callbackArgIndex];
+        if (argument.type !== _utils.AST_NODE_TYPES.Identifier) {
+          context.report({
+            node: argument,
+            messageId: 'noDoneCallback'
+          });
+          return;
+        }
+        if (callback.async) {
+          context.report({
+            node: argument,
+            messageId: 'useAwaitInsteadOfCallback'
+          });
+          return;
+        }
+        context.report({
+          node: argument,
+          messageId: 'noDoneCallback',
+          suggest: [{
+            messageId: 'suggestWrappingInPromise',
+            data: {
+              callback: argument.name
+            },
+            fix(fixer) {
+              const {
+                body,
+                params
+              } = callback;
+              const {
+                sourceCode
+              } = context;
+              const firstBodyToken = sourceCode.getFirstToken(body);
+              const lastBodyToken = sourceCode.getLastToken(body);
+              const [firstParam] = params;
+              const lastParam = params[params.length - 1];
+              const tokenBeforeFirstParam = sourceCode.getTokenBefore(firstParam);
+              let tokenAfterLastParam = sourceCode.getTokenAfter(lastParam);
+              if (tokenAfterLastParam?.value === ',') {
+                tokenAfterLastParam = sourceCode.getTokenAfter(tokenAfterLastParam);
+              }
+
+              /* istanbul ignore if */
+              if (!firstBodyToken || !lastBodyToken || !tokenBeforeFirstParam || !tokenAfterLastParam) {
+                throw new Error(`Unexpected null when attempting to fix ${context.filename} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
+              }
+              let argumentFix = fixer.replaceText(firstParam, '()');
+              if (tokenBeforeFirstParam.value === '(' && tokenAfterLastParam.value === ')') {
+                argumentFix = fixer.removeRange([tokenBeforeFirstParam.range[1], tokenAfterLastParam.range[0]]);
+              }
+              const newCallback = argument.name;
+              let beforeReplacement = `new Promise(${newCallback} => `;
+              let afterReplacement = ')';
+              let replaceBefore = true;
+              if (body.type === _utils.AST_NODE_TYPES.BlockStatement) {
+                const keyword = 'return';
+                beforeReplacement = `${keyword} ${beforeReplacement}{`;
+                afterReplacement += '}';
+                replaceBefore = false;
+              }
+              return [argumentFix, replaceBefore ? fixer.insertTextBefore(firstBodyToken, beforeReplacement) : fixer.insertTextAfter(firstBodyToken, beforeReplacement), fixer.insertTextAfter(lastBodyToken, afterReplacement)];
+            }
+          }]
+        });
+      }
+    };
+  }
+});

package/lib/rules/no-duplicate-hooks.js

@@ -0,0 +1,52 @@
+"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: 'Disallow duplicate setup and teardown hooks'
+    },
+    messages: {
+      noDuplicateHook: 'Duplicate {{hook}} in describe block'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    const hookContexts = [{}];
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type === 'describe') {
+          hookContexts.push({});
+        }
+        if (jestFnCall?.type !== 'hook') {
+          return;
+        }
+        const currentLayer = hookContexts[hookContexts.length - 1];
+        currentLayer[jestFnCall.name] ||= 0;
+        currentLayer[jestFnCall.name] += 1;
+        if (currentLayer[jestFnCall.name] > 1) {
+          context.report({
+            messageId: 'noDuplicateHook',
+            data: {
+              hook: jestFnCall.name
+            },
+            node
+          });
+        }
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe'])) {
+          hookContexts.pop();
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-error-equal.js

@@ -0,0 +1,41 @@
+"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 equality matchers on error types',
+      requiresTypeChecking: true
+    },
+    messages: {
+      equalError: 'Avoid using equality matchers to check errors'
+    },
+    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 || !['toEqual', 'toStrictEqual'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher))) {
+          return;
+        }
+        const [argument] = jestFnCall.head.node.parent.arguments;
+        if ((0, _utils2.isBuiltinSymbolLike)(services.program, services.getTypeAtLocation(argument), 'Error')) {
+          context.report({
+            messageId: 'equalError',
+            node
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-export.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 `exports` in files containing tests'
+    },
+    messages: {
+      unexpectedExport: `Do not export from a test file`
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const exportNodes = [];
+    let hasTestCase = false;
+    return {
+      'Program:exit'() {
+        if (hasTestCase && exportNodes.length > 0) {
+          for (const node of exportNodes) {
+            context.report({
+              node,
+              messageId: 'unexpectedExport'
+            });
+          }
+        }
+      },
+      CallExpression(node) {
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+          hasTestCase = true;
+        }
+      },
+      'ExportNamedDeclaration, ExportDefaultDeclaration, TSExportAssignment'(node) {
+        exportNodes.push(node);
+      },
+      'AssignmentExpression > MemberExpression'(node) {
+        let {
+          object,
+          property
+        } = node;
+        if (object.type === _utils.AST_NODE_TYPES.MemberExpression) {
+          ({
+            object,
+            property
+          } = object);
+        }
+        if ('name' in object && object.name === 'module' && property.type === _utils.AST_NODE_TYPES.Identifier && /^exports?$/u.test(property.name)) {
+          exportNodes.push(node);
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-focused-tests.js

@@ -0,0 +1,63 @@
+"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 focused tests'
+    },
+    messages: {
+      focusedTest: 'Unexpected focused test',
+      suggestRemoveFocus: 'Remove focus from test'
+    },
+    schema: [],
+    type: 'suggestion',
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'test' && jestFnCall?.type !== 'describe') {
+          return;
+        }
+        if (jestFnCall.name.startsWith('f')) {
+          context.report({
+            messageId: 'focusedTest',
+            node: jestFnCall.head.node,
+            suggest: [{
+              messageId: 'suggestRemoveFocus',
+              fix(fixer) {
+                // don't apply the fixer if we're an aliased import
+                if (jestFnCall.head.type === 'import' && jestFnCall.name !== jestFnCall.head.local) {
+                  return null;
+                }
+                return fixer.removeRange([node.range[0], node.range[0] + 1]);
+              }
+            }]
+          });
+          return;
+        }
+        const onlyNode = jestFnCall.members.find(s => (0, _utils2.getAccessorValue)(s) === 'only');
+        if (!onlyNode) {
+          return;
+        }
+        context.report({
+          messageId: 'focusedTest',
+          node: onlyNode,
+          suggest: [{
+            messageId: 'suggestRemoveFocus',
+            fix: fixer => fixer.removeRange([onlyNode.range[0] - 1, onlyNode.range[1] + Number(onlyNode.type !== _utils.AST_NODE_TYPES.Identifier)])
+          }]
+        });
+      }
+    };
+  }
+});

package/lib/rules/no-hooks.js

@@ -0,0 +1,51 @@
+"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: 'Disallow setup and teardown hooks'
+    },
+    messages: {
+      unexpectedHook: "Unexpected '{{ hookName }}' hook"
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        allow: {
+          type: 'array',
+          // @ts-expect-error https://github.com/eslint/eslint/discussions/17573
+          contains: ['beforeAll', 'beforeEach', 'afterAll', 'afterEach']
+        }
+      },
+      additionalProperties: false
+    }],
+    type: 'suggestion'
+  },
+  defaultOptions: [{
+    allow: []
+  }],
+  create(context, [{
+    allow = []
+  }]) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (jestFnCall?.type === 'hook' && !allow.includes(jestFnCall.name)) {
+          context.report({
+            node,
+            messageId: 'unexpectedHook',
+            data: {
+              hookName: jestFnCall.name
+            }
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-identical-title.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+const newDescribeContext = () => ({
+  describeTitles: [],
+  testTitles: []
+});
+var _default = exports.default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow identical titles'
+    },
+    messages: {
+      multipleTestTitle: 'Test title is used multiple times in the same describe block',
+      multipleDescribeTitle: 'Describe block title is used multiple times in the same describe block'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    const contexts = [newDescribeContext()];
+    return {
+      CallExpression(node) {
+        const currentLayer = contexts[contexts.length - 1];
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+        if (!jestFnCall) {
+          return;
+        }
+        if (jestFnCall.type === 'describe') {
+          contexts.push(newDescribeContext());
+        }
+        if (jestFnCall.members.find(s => (0, _utils.isSupportedAccessor)(s, 'each'))) {
+          return;
+        }
+        const [argument] = node.arguments;
+        if (!argument || !(0, _utils.isStringNode)(argument)) {
+          return;
+        }
+        const title = (0, _utils.getStringValue)(argument);
+        if (jestFnCall.type === 'test') {
+          if (currentLayer.testTitles.includes(title)) {
+            context.report({
+              messageId: 'multipleTestTitle',
+              node: argument
+            });
+          }
+          currentLayer.testTitles.push(title);
+        }
+        if (jestFnCall.type !== 'describe') {
+          return;
+        }
+        if (currentLayer.describeTitles.includes(title)) {
+          context.report({
+            messageId: 'multipleDescribeTitle',
+            node: argument
+          });
+        }
+        currentLayer.describeTitles.push(title);
+      },
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe'])) {
+          contexts.pop();
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-interpolation-in-snapshots.js

@@ -0,0 +1,43 @@
+"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 string interpolation inside snapshots'
+    },
+    messages: {
+      noInterpolation: 'Do not use string interpolation inside of snapshots'
+    },
+    schema: [],
+    type: 'problem'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher))) {
+          // Check all since the optional 'propertyMatchers' argument might be present
+          jestFnCall.args.forEach(argument => {
+            if (argument.type === _utils.AST_NODE_TYPES.TemplateLiteral && argument.expressions.length > 0) {
+              context.report({
+                messageId: 'noInterpolation',
+                node: argument
+              });
+            }
+          });
+        }
+      }
+    };
+  }
+});